コード例 #1
0
def all_rlp_fields_to_dict_camel_case(
    rlp_object: Union[rlp.Serializable, List, Tuple]
) -> Union[Dict[str, any], List[any]]:
    #It is either rlp.Serializable or a list
    if isinstance(rlp_object, rlp.Serializable):
        dict_to_return = {}
        # add all of the fields in camelcase
        for i in range(len(rlp_object._meta.field_names)):
            field_name = rlp_object._meta.field_names[i]
            key = underscore_to_camel_case(field_name)
            raw_val = getattr(rlp_object, field_name)
            if isinstance(raw_val, rlp.Serializable) or isinstance(
                    raw_val, list) or isinstance(raw_val, tuple):
                val = all_rlp_fields_to_dict_camel_case(raw_val)
            else:
                val = to_hex(raw_val)

            dict_to_return[key] = val
        return dict_to_return
    else:
        list_to_return = []
        for i in range(len(rlp_object)):
            raw_val = rlp_object[i]
            if isinstance(raw_val, rlp.Serializable) or isinstance(
                    raw_val, list) or isinstance(raw_val, tuple):
                val = all_rlp_fields_to_dict_camel_case(raw_val)
            else:
                val = to_hex(raw_val)
            list_to_return.append(val)
        return list_to_return
コード例 #2
0
ファイル: servers.py プロジェクト: Flamboy78/trinity
 async def handle_get_block_bodies(self, peer: ETHPeer,
                                   block_hashes: Sequence[Hash32]) -> None:
     if not peer.is_operational:
         return
     self.logger.debug2("%s requested bodies for %d blocks", peer,
                        len(block_hashes))
     bodies = []
     # Only serve up to MAX_BODIES_FETCH items in every request.
     for block_hash in block_hashes[:MAX_BODIES_FETCH]:
         try:
             header = await self.wait(
                 self.db.coro_get_block_header_by_hash(block_hash))
         except HeaderNotFound:
             self.logger.debug("%s asked for a block we don't have: %s",
                               peer, to_hex(block_hash))
             continue
         try:
             transactions = await self.wait(
                 self.db.coro_get_block_transactions(
                     header, BaseTransactionFields))
         except MissingTrieNode as exc:
             self.logger.debug(
                 "%s asked for block transactions we don't have: %s, "
                 "due to %r",
                 peer,
                 to_hex(block_hash),
                 exc,
             )
             continue
         uncles = await self.wait(
             self.db.coro_get_block_uncles(header.uncles_hash))
         bodies.append(BlockBody(transactions, uncles))
     self.logger.debug2("Replying to %s with %d block bodies", peer,
                        len(bodies))
     peer.sub_proto.send_block_bodies(bodies)
コード例 #3
0
ファイル: rest.py プロジェクト: realflash7/raiden
    def initiate_payment(
        self,
        registry_address: typing.PaymentNetworkID,
        token_address: typing.TokenAddress,
        target_address: typing.Address,
        amount: typing.TokenAmount,
        identifier: typing.PaymentID,
    ):
        log.debug(
            'Initiating payment',
            node=pex(self.raiden_api.address),
            registry_address=to_checksum_address(registry_address),
            token_address=to_checksum_address(token_address),
            target_address=to_checksum_address(target_address),
            amount=amount,
            payment_identifier=identifier,
        )

        if identifier is None:
            identifier = create_default_identifier()

        try:
            payment_status = self.raiden_api.transfer(
                registry_address=registry_address,
                token_address=token_address,
                target=target_address,
                amount=amount,
                identifier=identifier,
            )
        except (InvalidAmount, InvalidAddress, PaymentConflict,
                UnknownTokenAddress) as e:
            return api_error(
                errors=str(e),
                status_code=HTTPStatus.CONFLICT,
            )
        except InsufficientFunds as e:
            return api_error(
                errors=str(e),
                status_code=HTTPStatus.PAYMENT_REQUIRED,
            )

        if payment_status.payment_done is False:
            return api_error(
                errors="Payment couldn't be completed "
                "(insufficient funds, no route to target or target offline).",
                status_code=HTTPStatus.CONFLICT,
            )

        payment = {
            'initiator_address': self.raiden_api.address,
            'registry_address': registry_address,
            'token_address': token_address,
            'target_address': target_address,
            'amount': amount,
            'identifier': identifier,
            'secret': to_hex(payment_status.secret),
            'secret_hash': to_hex(payment_status.secret_hash),
        }
        result = self.payment_schema.dump(payment)
        return api_response(result=result.data)
コード例 #4
0
ファイル: servers.py プロジェクト: Flamboy78/trinity
 async def handle_get_receipts(self, peer: ETHPeer,
                               block_hashes: Sequence[Hash32]) -> None:
     if not peer.is_operational:
         return
     self.logger.debug2("%s requested receipts for %d blocks", peer,
                        len(block_hashes))
     receipts = []
     # Only serve up to MAX_RECEIPTS_FETCH items in every request.
     for block_hash in block_hashes[:MAX_RECEIPTS_FETCH]:
         try:
             header = await self.wait(
                 self.db.coro_get_block_header_by_hash(block_hash))
         except HeaderNotFound:
             self.logger.debug(
                 "%s asked receipts for a block we don't have: %s", peer,
                 to_hex(block_hash))
             continue
         try:
             block_receipts = await self.wait(
                 self.db.coro_get_receipts(header, Receipt))
         except MissingTrieNode as exc:
             self.logger.debug(
                 "%s asked for block receipts we don't have: %s, "
                 "due to %r",
                 peer,
                 to_hex(block_hash),
                 exc,
             )
             continue
         receipts.append(block_receipts)
     self.logger.debug2("Replying to %s with receipts for %d blocks", peer,
                        len(receipts))
     peer.sub_proto.send_receipts(receipts)
コード例 #5
0
ファイル: servers.py プロジェクト: rsinghIND/trinity
    async def handle_get_receipts(self, peer: ETHProxyPeer, command: GetReceiptsV65) -> None:
        block_hashes = command.payload

        self.logger.debug2("%s requested receipts for %d blocks", peer, len(block_hashes))
        receipts = []
        # Only serve up to MAX_RECEIPTS_FETCH items in every request.
        for block_hash in block_hashes[:MAX_RECEIPTS_FETCH]:
            try:
                header = await self.db.coro_get_block_header_by_hash(block_hash)
            except HeaderNotFound:
                self.logger.debug(
                    "%s asked receipts for a block we don't have: %s", peer, to_hex(block_hash)
                )
                continue
            vm_class = self._chain_class.get_vm_class_for_block_number(header.block_number)
            try:
                block_receipts = await self.db.coro_get_receipts(
                    header,
                    vm_class.get_receipt_builder(),
                )
            except MissingTrieNode as exc:
                self.logger.debug(
                    "%s asked for block receipts we don't have: %s, "
                    "due to %r",
                    peer,
                    to_hex(block_hash),
                    exc,
                )
                continue
            receipts.append(block_receipts)
        self.logger.debug2("Replying to %s with receipts for %d blocks", peer, len(receipts))
        peer.eth_api.send_receipts(receipts)
コード例 #6
0
def update_iou(
    iou: typing.Dict[str, typing.Any],
    privkey: bytes,
    added_amount: typing.TokenAmount = 0,
    expiration_block: typing.Optional[typing.BlockNumber] = None,
) -> typing.Dict[str, typing.Any]:

    expected_signature = to_hex(
        sign_one_to_n_iou(
            privatekey=to_hex(privkey),
            expiration=iou['expiration_block'],
            sender=iou['sender'],
            receiver=iou['receiver'],
            amount=iou['amount'],
        ))
    if iou.get('signature') != expected_signature:
        raise ServiceRequestFailed(
            'Last IOU as given by the pathfinding service is invalid (signature does not match)',
        )

    iou['amount'] += added_amount
    if expiration_block:
        iou['expiration_block'] = expiration_block

    iou['signature'] = sign_one_to_n_iou(
        privatekey=to_hex(privkey),
        expiration=iou['expiration_block'],
        sender=iou['sender'],
        receiver=iou['receiver'],
        amount=iou['amount'],
    )

    return iou
コード例 #7
0
def create_latest_block_uri(w3: Web3, tx_receipt: TxReceipt) -> URI:
    """
    Creates a new block uri from data in w3 and provided tx_receipt.
    """
    chain_id = to_hex(get_genesis_block_hash(w3))
    block_hash = to_hex(tx_receipt.blockHash)
    return create_block_uri(chain_id, block_hash)
コード例 #8
0
async def retrieve_block(w3: Web3, block_number: int) -> Block:
    block_data = await trio.to_thread.run_sync(w3.eth.getBlock, block_number, True)
    transactions_data = cast(Sequence[TxData], block_data["transactions"])

    transaction_hashes = tuple(to_hex(tx_data["hash"]) for tx_data in transactions_data)
    receipts_data = await gather(
        *(
            (trio.to_thread.run_sync, w3.eth.getTransactionReceipt, transaction_hash)
            for transaction_hash in transaction_hashes
        )
    )

    uncles_data = await gather(
        *(
            (
                trio.to_thread.run_sync,
                w3.eth.getUncleByBlock,
                to_hex(block_data["hash"]),
                idx,
            )
            for idx in range(len(block_data["uncles"]))
        )
    )

    return extract_block(
        block_data,
        transactions_data=transactions_data,
        uncles_data=uncles_data,
        receipts_data=receipts_data,
    )
コード例 #9
0
ファイル: clr.py プロジェクト: willmeister/quadratic-funding
def check_addresses(backers):
    result = []
    for backer in backers:
        if not is_hex(backer):
            to_hex(backer)
        result.append(backer)
    return result
コード例 #10
0
def update_iou(
    iou: Dict[str, Any],
    privkey: bytes,
    added_amount: TokenAmount = ZERO_TOKENS,
    expiration_block: Optional[BlockNumber] = None,
) -> Dict[str, Any]:

    expected_signature = to_hex(
        sign_one_to_n_iou(
            privatekey=to_hex(privkey),
            expiration=iou["expiration_block"],
            sender=iou["sender"],
            receiver=iou["receiver"],
            amount=iou["amount"],
        ))
    if iou.get("signature") != expected_signature:
        raise ServiceRequestFailed(
            "Last IOU as given by the pathfinding service is invalid (signature does not match)"
        )

    iou["amount"] += added_amount
    if expiration_block:
        iou["expiration_block"] = expiration_block

    iou["signature"] = to_hex(
        sign_one_to_n_iou(
            privatekey=to_hex(privkey),
            expiration=iou["expiration_block"],
            sender=iou["sender"],
            receiver=iou["receiver"],
            amount=iou["amount"],
        ))

    return iou
コード例 #11
0
def main():
    try:
        # Connect to web3
        w3 = connect_to_web3(URL)

        # Load contracts
        Ransom = load_contract(w3, os.path.join(PATH, 'Ransom.json'))
        Escrow = load_contract(w3, os.path.join(PATH, 'Escrow.json'))
        Registry = load_contract(w3, os.path.join(PATH, 'Escrow.json'))
        escrow_contract = Escrow(address=w3.toChecksumAddress(ESCROW_ADDRESS))
        registry_contract = Registry(
            address=w3.toChecksumAddress(REGISTRY_ADDRESS))
        ransom_contract = Ransom(address=w3.toChecksumAddress(RANSOM_ADDRESS))

        victims = []

        with open('victims.txt') as v:
            for line in v:
                victims.append(line.strip())

        with open('payed_accounts.txt') as p:
            for line in p:
                m = w3.eth.getBalance(w3.toChecksumAddress(line.strip()))
                print(w3.fromWei(m, 'ether'))

        pos = str(7).rjust(64, '0')
        storage_key = to_hex(w3.sha3(hexstr=pos))
        user = w3.toHex(
            w3.eth.getStorageAt(w3.toChecksumAddress(ESCROW_ADDRESS),
                                storage_key))
        print("User Address:", user)
        print(w3.toHex(w3.eth.getBalance(
            w3.toChecksumAddress(ESCROW_ADDRESS))))

        x = w3.eth.getBalance(w3.toChecksumAddress(MYRANSOM_ADDRESS))
        print("My Ransom Balance:", w3.fromWei(x, 'ether'))

        for v in victims:
            print("Victim:", v)
            key = remove_0x_prefix(v).rjust(64, '0').lower()
            pos = str(3).rjust(64, '0')
            storage_key = to_hex(w3.sha3(hexstr=key + pos))
            print(
                w3.toHex(
                    w3.eth.getStorageAt(w3.toChecksumAddress(ESCROW_ADDRESS),
                                        storage_key)))
        ''' 
        for x in range(0, 20): 
            pos = str(1).rjust(64, '0')
            storage_key = hex(int(to_hex(w3.sha3(hexstr=pos)),16) + x)
            print(w3.toHex(w3.eth.getStorageAt(w3.toChecksumAddress(ESCROWADDRESS), storage_key)))
        '''
    except requests.exceptions.HTTPError as http_err:
        LOG.error("web3 connection failure: {0}".format(http_err))
        return 2
    except Exception as e:
        LOG.error("Caught exception: {0}".format(e))
        return 3

    return 0
コード例 #12
0
def transaction(simple_contract_address):
    function_selector = function_signature_to_4byte_selector('getMeaningOfLife()')
    return {
        'from': '0x' + 'ff' * 20,  # unfunded address
        'to': to_hex(simple_contract_address),
        'gasPrice': to_hex(0),
        'data': to_hex(function_selector),
    }
コード例 #13
0
def ProcessEpoch(block_num):
	blk = rpc.eth.getBlock(to_hex(block_num))
	#blk = api.models.block.Block.objects.get(id=block_id)
	slashedNode = []
	epoch = blk.number // settings.BLOCKS_PER_EPOCH
	log.info('\tProcessing epoch at block {0}.'.format(block_num))
	if epoch > 0:
		end_block = blk.number - 1
		start_block = end_block - settings.BLOCKS_PER_EPOCH + 1
		s_b = rpc.eth.getBlock(to_hex(start_block))
		e,created = api.models.epoch.Epoch.objects.get_or_create(
			epoch = epoch,
			defaults = {
				'epoch':epoch,
				'startTime': pytz.utc.localize(datetime.fromtimestamp(float(s_b.timestamp))),
				'endTime': pytz.utc.localize(datetime.fromtimestamp(float(blk.timestamp))),
				'startBlock': start_block,
				'endBlock': end_block,
				'isActive': False,
			},
		)
		e.startTime= pytz.utc.localize(datetime.fromtimestamp(float(s_b.timestamp)))
		e.isActive = False
		ne,necreated = api.models.epoch.Epoch.objects.get_or_create(
			epoch = epoch + 1,
			defaults = {
				'epoch':epoch + 1,
				'startTime':pytz.utc.localize(datetime.fromtimestamp(float(s_b.timestamp))),
				'endTime':pytz.utc.localize(datetime.fromtimestamp(float(s_b.timestamp))),
				'startBlock': blk.number,
				'endBlock': blk.number + settings.BLOCKS_PER_EPOCH - 1,
				'isActive': True,
			},
		)
		e.save()
		ne.save()
		if (blk.penalties != "0x"):
			for addr in zip(islice(blk.penalties[2:], 0, None, 20)):
				if addr.len() > 0:
					slashedNode.append(addr)

				if (slashedNode.len() > 0):
					for i in range(0,4):
						nextEpoch = epoch + 1 + i
						e,created = api.models.epoch.Epoch.objects.get_or_create(
							epoch = nextEpoch,
							defaults = {
								'epoch':nextEpoch,
								'startTime':pytz.utc.localize(datetime.fromtimestamp(float(s_b.timestamp))),
								'startBlock': ((nextEpoch - 1) * settings.BLOCKS_PER_EPOCH),
								'endBlock': (nextEpoch * settings.BLOCKS_PER_EPOCH) - 1,
								'isActive': False,
								'slashedNode': str(slashedNode)
							},
						)
						if not created:
							e.slashedNode = str(ast.literal_eval(e.slashedNode).extend(slashedNode))
						e.save()
コード例 #14
0
def create_finalization_values(sk, balance, index, party):
    sigma_E_msg = "updated|" + str(index)
    sigma_E = w3.eth.account.sign_message(encode_defunct(text=sigma_E_msg),
                                          private_key=sk)
    msg = str(index) + "|" + str(balance) + "|0x" + str.upper(party[2:])
    sigma_i = to_hex(
        w3.eth.account.sign_message(encode_defunct(text=msg),
                                    private_key=sk).signature)
    return sigma_E_msg, to_hex(sigma_E.signature), msg, sigma_i
コード例 #15
0
def get_keys_from_file(keyfile_path, keyfile_password):
    with open(keyfile_path) as keyfile:
        encrypted_key = keyfile.read()
    private_key = w3.eth.account.decrypt(encrypted_key, keyfile_password)
    pk = keys.PrivateKey(private_key)

    private_key_hex = to_hex(private_key)  # hex string
    public_key_hex = to_hex(pk.public_key._raw_key)  # hex string

    return public_key_hex, private_key_hex
コード例 #16
0
def main():
    try:
        # Connect to web3
        w3 = connect_to_web3(URL)

        # Load contracts
        Ransom = load_contract(w3, os.path.join(PATH, 'Ransom.json'))
        Escrow = load_contract(w3, os.path.join(PATH, 'Escrow.json'))
        escrow_contract = Escrow(address=(ESCROW_ADDRESS))

        ransom_address = []
        victim_id = []
        fulfilled = []

        # Get all ransom addresses that the escrow is in charge of
        for x in range(0, 10):
            pos = str(9).rjust(64, '0')
            storage_key = hex(int(to_hex(w3.sha3(hexstr=pos)), 16) + x)
            ransom_address.append(
                w3.toHex(
                    w3.eth.getStorageAt(escrow_contract.address, storage_key)))
            #print("Ransom Address {0}".format(x), ransom_address[x])

        # Get victim IDs from the ransom addresses
        for x in range(0, 10):
            pos = str(6).rjust(64, '0')
            key = remove_0x_prefix(ransom_address[x]).rjust(64, "0").lower()
            storage_key = to_hex(w3.sha3(hexstr=key + pos))
            victim_id.append(
                w3.toHex(
                    w3.eth.getStorageAt(escrow_contract.address, storage_key)))
            #print("Victim ID {0}".format(x), victim_id[x])

        # Get contract fulfillment status
        for x in range(0, 10):
            address = remove_0x_prefix(ransom_address[x])
            #print(address[24:])
            ransom_contract = Ransom(
                address=w3.toChecksumAddress(address[24:]))
            result = ransom_contract.functions.isFulFilled().call()
            if result == True:
                fulfilled.append(victim_id[x])
            #print(result)

        for victim in victim_id:
            print(victim)

    except requests.exceptions.HTTPError as http_err:
        LOG.error("web3 connection failure: {0}".format(http_err))
        return 2
    except Exception as e:
        LOG.error("Caught exception: {0}".format(e))
        return 3

    return 0
コード例 #17
0
def test_insert_deployment(escrow_deployer):
    w3 = escrow_deployer.package.w3
    escrow_package = escrow_deployer.package
    init_deployment_data = {
        "contract_type": "Escrow",
        "address": "0x",
        "transaction": "0x",
        "block": "0x",
    }
    new_deployment_data = {
        "contract_type": "Escrow",
        "address": "0x123",
        "transaction": "0x123",
        "block": "0x123",
    }
    genesis_hash = to_hex(get_genesis_block_hash(w3))
    w3.testing.mine(1)
    init_block_hash = to_hex(w3.eth.getBlock("latest")["hash"])
    init_block_uri = create_block_uri(genesis_hash, init_block_hash)
    alt_block_uri = init_block_uri[:15] + "yxz123" + init_block_uri[21:]
    init_block_deployment_data = {
        init_block_uri: {
            "Other": {
                "x": "x"
            },
            "Escrow": init_deployment_data
        },
        alt_block_uri: {
            "alt": {
                "x": "x"
            }
        },
    }
    w3.testing.mine(1)
    new_block_hash = to_hex(w3.eth.getBlock("latest")["hash"])
    new_block_uri = create_block_uri(genesis_hash, new_block_hash)
    escrow_package.manifest = assoc(escrow_package.manifest, "deployments",
                                    init_block_deployment_data)
    updated_manifest = insert_deployment(escrow_package, "Escrow",
                                         new_deployment_data, new_block_uri)
    expected_deployments_data = {
        new_block_uri: {
            "Other": {
                "x": "x"
            },
            "Escrow": new_deployment_data
        },
        alt_block_uri: {
            "alt": {
                "x": "x"
            }
        },
    }
    assert updated_manifest["deployments"] == expected_deployments_data
コード例 #18
0
ファイル: _utils.py プロジェクト: nseidm1/1inchpython
def create_deployment_data(
    contract_name: ContractName,
    new_address: Address,
    tx_receipt: TxReceipt,
    link_refs: List[Dict[str, Any]] = None,
) -> Iterable[Tuple[str, Any]]:
    yield "contract_type", contract_name
    yield "address", new_address
    yield "transaction", to_hex(tx_receipt["transactionHash"])
    yield "block", to_hex(tx_receipt["blockHash"])
    if link_refs:
        yield "runtime_bytecode", {"link_dependencies": create_link_dep(link_refs)}
コード例 #19
0
def reward_type_2_to_dict(reward_type_2: StakeRewardType2) -> Dict[str, str]:
    dict_to_return = {}
    dict_to_return['amount'] = to_hex(reward_type_2.amount)

    dict_to_return['proof'] = []

    for proof in reward_type_2.proof:
        proof_dict = all_rlp_fields_to_dict_camel_case(proof)
        proof_dict['sender'] = to_hex(proof.sender)
        dict_to_return['proof'].append(proof_dict)

    return dict_to_return
コード例 #20
0
    def _maybe_run_callbacks(self, latest_block: BlockData) -> None:
        """Run the callbacks if there is at least one new block.

        The callbacks are executed only if there is a new block, otherwise the
        filters may try to poll for an inexisting block number and the Ethereum
        client can return an JSON-RPC error.
        """
        latest_block_number = latest_block["number"]

        # First run, set the block and run the callbacks
        if self.known_block_number is None:
            self.known_block_number = latest_block_number
            missed_blocks = 1
        else:
            missed_blocks = latest_block_number - self.known_block_number

        if missed_blocks < 0:
            log.critical(
                "Block number decreased",
                chain_id=self.rpc_client.chain_id,
                known_block_number=self.known_block_number,
                old_block_number=latest_block["number"],
                old_gas_limit=latest_block["gasLimit"],
                old_block_hash=to_hex(latest_block["hash"]),
                node=to_checksum_address(self.rpc_client.address),
            )
        elif missed_blocks > 0:
            log_details = dict(
                known_block_number=self.known_block_number,
                latest_block_number=latest_block_number,
                latest_block_hash=to_hex(latest_block["hash"]),
                latest_block_gas_limit=latest_block["gasLimit"],
                node=to_checksum_address(self.rpc_client.address),
            )
            if missed_blocks > 1:
                log_details["num_missed_blocks"] = missed_blocks - 1

            log.debug("Received new block", **log_details)

            remove = list()
            for callback in self.callbacks:
                result = callback(latest_block)
                if result is REMOVE_CALLBACK:
                    remove.append(callback)

            for callback in remove:
                self.callbacks.remove(callback)

            self.known_block_number = latest_block_number
コード例 #21
0
ファイル: test_ipc.py プロジェクト: mhchia/trinity
async def test_eth_call_with_contract_on_ipc(chain, jsonrpc_ipc_pipe_path,
                                             simple_contract_address,
                                             signature, gas_price, event_loop,
                                             ipc_server, expected):
    function_selector = function_signature_to_4byte_selector(signature)
    transaction = {
        'from': '0x' + 'ff' * 20,  # unfunded address
        'to': to_hex(simple_contract_address),
        'gasPrice': to_hex(gas_price),
        'data': to_hex(function_selector),
    }
    request_msg = build_request('eth_call', params=[transaction, 'latest'])
    result = await get_ipc_response(jsonrpc_ipc_pipe_path, request_msg,
                                    event_loop)
    assert result == expected
コード例 #22
0
def get_state_change_with_transfer_by_secrethash(
        storage: SerializedSQLiteStorage,
        secrethash: SecretHash) -> Optional[StateChangeRecord]:
    filters = [
        {
            "from_transfer.lock.secrethash": to_hex(secrethash)
        },
        {
            "transfer.lock.secrethash": to_hex(secrethash)
        },
    ]
    query = FilteredDBQuery(filters=filters,
                            main_operator=Operator.OR,
                            inner_operator=Operator.NONE)
    return storage.get_latest_state_change_by_data_field(query)
コード例 #23
0
def prep_chain_tx_send_data(tx):
    write_data = {
        "hash": to_hex(tx["hash"]),
        "blockHash": to_hex(tx["blockHash"]),
        "nonce": tx["nonce"],
        "gasPrice": tx["gasPrice"],
        "gas": tx["gas"],
        "to": tx["to"],
        "value": tx["value"],
        "input": tx["input"],
        "v": tx["v"],
        "r": Web3.toInt(tx["r"]),
        "s": Web3.toInt(tx["s"])
    }
    return write_data
コード例 #24
0
ファイル: encoding.py プロジェクト: nseidm1/1inchpython
def hex_encode_abi_type(abi_type: TypeStr,
                        value: Any,
                        force_size: int = None) -> HexStr:
    """
    Encodes value into a hex string in format of abi_type
    """
    validate_abi_type(abi_type)
    validate_abi_value(abi_type, value)

    data_size = force_size or size_of_type(abi_type)
    if is_array_type(abi_type):
        sub_type = sub_type_of_array_type(abi_type)
        return HexStr("".join([
            remove_0x_prefix(hex_encode_abi_type(sub_type, v, 256))
            for v in value
        ]))
    elif is_bool_type(abi_type):
        return to_hex_with_size(value, data_size)
    elif is_uint_type(abi_type):
        return to_hex_with_size(value, data_size)
    elif is_int_type(abi_type):
        return to_hex_twos_compliment(value, data_size)
    elif is_address_type(abi_type):
        return pad_hex(value, data_size)
    elif is_bytes_type(abi_type):
        if is_bytes(value):
            return encode_hex(value)
        else:
            return value
    elif is_string_type(abi_type):
        return to_hex(text=value)
    else:
        raise ValueError("Unsupported ABI type: {0}".format(abi_type))
コード例 #25
0
 def __init__(self, abi, address, block_height="latest"):
     self.abi = abi
     self.address = address
     if block_height != "latest":
         self.block_height = to_hex(block_height)
     else:
         self.block_height = block_height
コード例 #26
0
ファイル: encoding.py プロジェクト: zheewang/web3.py
def hex_encode_abi_type(abi_type, value, force_size=None):
    """
    Encodes value into a hex string in format of abi_type
    """
    validate_abi_type(abi_type)
    validate_abi_value(abi_type, value)

    data_size = force_size or size_of_type(abi_type)
    if is_array_type(abi_type):
        sub_type = sub_type_of_array_type(abi_type)
        return "".join([remove_0x_prefix(hex_encode_abi_type(sub_type, v, 256)) for v in value])
    elif is_bool_type(abi_type):
        return to_hex_with_size(value, data_size)
    elif is_uint_type(abi_type):
        return to_hex_with_size(value, data_size)
    elif is_int_type(abi_type):
        return to_hex_twos_compliment(value, data_size)
    elif is_address_type(abi_type):
        return pad_hex(value, data_size)
    elif is_bytes_type(abi_type):
        if is_bytes(value):
            return encode_hex(value)
        else:
            return value
    elif is_string_type(abi_type):
        return to_hex(text=value)
    else:
        raise ValueError(
            "Unsupported ABI type: {0}".format(abi_type)
        )
コード例 #27
0
def build_etherscan_manifest(uri: URI, package_name: str,
                             version: str) -> Iterable[Tuple[str, Any]]:
    address, chain_id = parse.urlparse(uri).netloc.split(":")
    network = get_etherscan_network(chain_id)
    body = make_etherscan_request(address, network)
    contract_type = body["ContractName"]
    w3 = setup_w3(to_int(text=chain_id))
    block_uri = create_latest_block_uri(w3)
    runtime_bytecode = to_hex(
        w3.eth.getCode(ChecksumAddress(HexAddress(HexStr(address)))))

    yield "package_name", package_name
    yield "version", version
    yield "manifest_version", "2"
    yield "sources", {f"./{contract_type}.sol": body["SourceCode"]}
    yield "contract_types", {
        contract_type: {
            "abi": json.loads(body["ABI"]),
            "runtime_bytecode": {
                "bytecode": runtime_bytecode
            },
            "compiler": generate_compiler_info(body),
        }
    }
    yield "deployments", {
        block_uri: {
            contract_type: {
                "contract_type": contract_type,
                "address": address
            }
        }
    }
コード例 #28
0
ファイル: pathfinding.py プロジェクト: christianbrb/raiden
def update_iou(
    iou: IOU,
    privkey: bytes,
    added_amount: TokenAmount = ZERO_TOKENS,
    expiration_block: Optional[BlockNumber] = None,
) -> IOU:

    expected_signature = Signature(
        sign_one_to_n_iou(
            privatekey=to_hex(privkey),
            sender=to_checksum_address(iou.sender),
            receiver=to_checksum_address(iou.receiver),
            amount=iou.amount,
            expiration_block=iou.expiration_block,
            one_to_n_address=to_checksum_address(iou.one_to_n_address),
            chain_id=iou.chain_id,
        ))
    if iou.signature != expected_signature:
        raise ServiceRequestFailed(
            "Last IOU as given by the Pathfinding Service is invalid (signature does not match)"
        )

    iou.amount = TokenAmount(iou.amount + added_amount)
    if expiration_block:
        iou.expiration_block = expiration_block

    iou.sign(privkey)

    return iou
コード例 #29
0
ファイル: ethrpcops.py プロジェクト: sonicskye/btcrelay-ui
def getstorageatindex(contractaddress, i, k, provider='http://127.0.0.1:8545'):
    web3 = Web3(Web3.HTTPProvider(provider, request_kwargs={'timeout': 60}))
    pos = str(remove_0x_prefix(i)).rjust(64, '0')
    key = remove_0x_prefix(k).rjust(64, '0').lower()
    storage_key = to_hex(web3.sha3(hexstr=key + pos))
    return storage_key, to_int(
        web3.eth.getStorageAt(contractaddress, storage_key))
コード例 #30
0
ファイル: ethrpcops.py プロジェクト: sonicskye/btcrelay-ui
def getstoragepos(i, k):
    #pos = str(i).rjust(64, '0')
    pos = getstoragekey(i, k)
    #print(pos)
    key = str(remove_0x_prefix(pos)).rjust(64, '0').lower()
    storage_key = to_hex(Web3auto.sha3(hexstr=key))
    return storage_key
コード例 #31
0
def create_account_console(logger: Logger, network: str):
    """Creates an Ethereum account and echoes the details to console."""

    acc = Account.create()
    private_key = to_hex(acc.privateKey)

    if private_key.startswith("0x"):
        # Looks like this behaves differently in different versions,
        # we assume no 0x prefix for private key to distinguish it from addresses
        # and hashes
        private_key = private_key[2:]

    logger.info("Account address: %s", acc.address)
    logger.info("Account private key: %s", private_key)

    config = CONFIG_FILE_TEMPLATE.format(private_key=private_key,
                                         network=network,
                                         address=acc.address)
    config_file_name = "myconfig.ini"

    print()
    print("Create a file {}{}{} and paste in the following content: {}{}{}".
          format(colorama.Fore.LIGHTBLUE_EX, config_file_name,
                 colorama.Fore.RESET, colorama.Fore.LIGHTBLACK_EX, config,
                 colorama.Fore.RESET))
    print()
    print("After this you can run {}sto --config-file={} diagnose{}".format(
        colorama.Fore.LIGHTBLUE_EX, config_file_name, colorama.Fore.RESET))
コード例 #32
0
ファイル: tasks.py プロジェクト: hackaugusto/raiden
    def _maybe_run_callbacks(self, latest_block):
        """ Run the callbacks if there is at least one new block.

        The callbacks are executed only if there is a new block, otherwise the
        filters may try to poll for an inexisting block number and the Ethereum
        client can return an JSON-RPC error.
        """
        assert self.known_block_number is not None, 'known_block_number not set'

        latest_block_number = latest_block['number']
        missed_blocks = latest_block_number - self.known_block_number

        if missed_blocks < 0:
            log.critical(
                'Block number decreased',
                chain_id=self.chain_id,
                known_block_number=self.known_block_number,
                old_block_number=latest_block['number'],
                old_gas_limit=latest_block['gasLimit'],
                old_block_hash=to_hex(latest_block['hash']),
            )
        elif missed_blocks > 0:
            log_details = dict(
                known_block_number=self.known_block_number,
                latest_block_number=latest_block_number,
                latest_block_hash=to_hex(latest_block['hash']),
                latest_block_gas_limit=latest_block['gasLimit'],
            )
            if missed_blocks > 1:
                log_details['num_missed_blocks'] = missed_blocks - 1

            log.debug(
                'Received new block',
                **log_details,
            )

            remove = list()
            for callback in self.callbacks:
                result = callback(latest_block)
                if result is REMOVE_CALLBACK:
                    remove.append(callback)

            for callback in remove:
                self.callbacks.remove(callback)

            self.known_block_number = latest_block_number
コード例 #33
0
ファイル: encoding.py プロジェクト: zheewang/web3.py
def to_bytes(primitive=None, hexstr=None, text=None):
    assert_one_val(primitive, hexstr=hexstr, text=text)

    if is_boolean(primitive):
        return b'\x01' if primitive else b'\x00'
    elif isinstance(primitive, bytes):
        return primitive
    elif is_integer(primitive):
        return to_bytes(hexstr=to_hex(primitive))
    elif hexstr is not None:
        if len(hexstr) % 2:
            hexstr = '0x0' + remove_0x_prefix(hexstr)
        return decode_hex(hexstr)
    elif text is not None:
        return text.encode('utf-8')
    raise TypeError("expected an int in first arg, or keyword of hexstr or text")
コード例 #34
0
ファイル: tasks.py プロジェクト: hackaugusto/raiden
    def first_run(self, known_block_number):
        """ Blocking call to update the local state, if necessary. """
        assert self.callbacks, 'callbacks not set'

        chain_id = self.chain.network_id
        latest_block = self.chain.get_block(block_identifier='latest')

        log.debug(
            'Alarm task first run',
            known_block_number=known_block_number,
            latest_block_number=latest_block['number'],
            latest_gas_limit=latest_block['gasLimit'],
            latest_block_hash=to_hex(latest_block['hash']),
        )

        self.known_block_number = known_block_number
        self.chain_id = chain_id
        self._maybe_run_callbacks(latest_block)
コード例 #35
0
ファイル: events.py プロジェクト: miohtama/web3.py
 def topics(self):
     arg_topics = tuple(arg.match_values for arg in self.indexed_args)
     return normalize_topic_list(cons(to_hex(self.event_topic), arg_topics))
コード例 #36
0
ファイル: events.py プロジェクト: miohtama/web3.py
 def _encode(self, value):
     if is_dynamic_sized_type(self.arg_type):
         return to_hex(keccak(encode_single_packed(self.arg_type, value)))
     else:
         return to_hex(encode_single(self.arg_type, value))
コード例 #37
0
    def handle_contract_send_channelsettle(
            self,
            raiden: RaidenService,
            channel_settle_event: ContractSendChannelSettle,
    ):
        chain_id = raiden.chain.network_id
        token_network_identifier = channel_settle_event.token_network_identifier
        channel_identifier = channel_settle_event.channel_identifier

        payment_channel: PaymentChannel = raiden.chain.payment_channel(
            token_network_address=channel_settle_event.token_network_identifier,
            channel_id=channel_settle_event.channel_identifier,
        )

        token_network_proxy: TokenNetwork = payment_channel.token_network
        participants_details = token_network_proxy.detail_participants(
            participant1=payment_channel.participant1,
            participant2=payment_channel.participant2,
            channel_identifier=channel_settle_event.channel_identifier,
        )

        our_details = participants_details.our_details
        partner_details = participants_details.partner_details

        log_details = {
            'chain_id': chain_id,
            'token_network_identifier': token_network_identifier,
            'channel_identifier': channel_identifier,
            'node': pex(raiden.address),
            'partner': to_checksum_address(partner_details.address),
            'our_deposit': our_details.deposit,
            'our_withdrawn': our_details.withdrawn,
            'our_is_closer': our_details.is_closer,
            'our_balance_hash': to_hex(our_details.balance_hash),
            'our_nonce': our_details.nonce,
            'our_locksroot': to_hex(our_details.locksroot),
            'our_locked_amount': our_details.locked_amount,
            'partner_deposit': partner_details.deposit,
            'partner_withdrawn': partner_details.withdrawn,
            'partner_is_closer': partner_details.is_closer,
            'partner_balance_hash': to_hex(partner_details.balance_hash),
            'partner_nonce': partner_details.nonce,
            'partner_locksroot': to_hex(partner_details.locksroot),
            'partner_locked_amount': partner_details.locked_amount,
        }

        if our_details.balance_hash != EMPTY_HASH:
            event_record = get_event_with_balance_proof_by_balance_hash(
                storage=raiden.wal.storage,
                chain_id=chain_id,
                token_network_identifier=token_network_identifier,
                channel_identifier=channel_identifier,
                balance_hash=our_details.balance_hash,
            )

            if event_record.data is None:
                log.critical(
                    'our balance proof not found',
                    **log_details,
                )
                raise RaidenUnrecoverableError(
                    'Our balance proof could not be found in the database',
                )

            our_balance_proof = event_record.data.balance_proof
            our_transferred_amount = our_balance_proof.transferred_amount
            our_locked_amount = our_balance_proof.locked_amount
            our_locksroot = our_balance_proof.locksroot
        else:
            our_transferred_amount = 0
            our_locked_amount = 0
            our_locksroot = EMPTY_HASH

        if partner_details.balance_hash != EMPTY_HASH:
            state_change_record = get_state_change_with_balance_proof_by_balance_hash(
                storage=raiden.wal.storage,
                chain_id=chain_id,
                token_network_identifier=token_network_identifier,
                channel_identifier=channel_identifier,
                balance_hash=partner_details.balance_hash,
                sender=participants_details.partner_details.address,
            )
            if state_change_record.data is None:
                log.critical(
                    'partner balance proof not found',
                    **log_details,
                )
                raise RaidenUnrecoverableError(
                    'Partner balance proof could not be found in the database',
                )

            partner_balance_proof = state_change_record.data.balance_proof
            partner_transferred_amount = partner_balance_proof.transferred_amount
            partner_locked_amount = partner_balance_proof.locked_amount
            partner_locksroot = partner_balance_proof.locksroot
        else:
            partner_transferred_amount = 0
            partner_locked_amount = 0
            partner_locksroot = EMPTY_HASH

        payment_channel.settle(
            our_transferred_amount,
            our_locked_amount,
            our_locksroot,
            partner_transferred_amount,
            partner_locked_amount,
            partner_locksroot,
        )
コード例 #38
0
ファイル: settings.py プロジェクト: hackaugusto/raiden
from eth_utils import denoms, to_hex

from raiden.constants import Environment

INITIAL_PORT = 38647

CACHE_TTL = 60
GAS_LIMIT = 10 * 10**6
GAS_LIMIT_HEX = to_hex(GAS_LIMIT)
GAS_PRICE = denoms.shannon * 20  # pylint: disable=no-member

DEFAULT_TRANSPORT_RETRIES_BEFORE_BACKOFF = 5
DEFAULT_TRANSPORT_THROTTLE_CAPACITY = 10.
DEFAULT_TRANSPORT_THROTTLE_FILL_RATE = 10.
DEFAULT_TRANSPORT_UDP_RETRY_INTERVAL = 1.
# matrix gets spammed with the default retry-interval of 1s, wait a little more
DEFAULT_TRANSPORT_MATRIX_RETRY_INTERVAL = 5.
DEFAULT_MATRIX_KNOWN_SERVERS = {
    Environment.PRODUCTION: (
        "https://raw.githubusercontent.com/raiden-network/raiden-transport"
        "/master/known_servers.main.yaml"
    ),
    Environment.DEVELOPMENT: (
        "https://raw.githubusercontent.com/raiden-network/raiden-transport"
        "/master/known_servers.test.yaml"
    ),
}

DEFAULT_REVEAL_TIMEOUT = 50
DEFAULT_SETTLE_TIMEOUT = 500
DEFAULT_RETRY_TIMEOUT = 0.5
コード例 #39
0
ファイル: encoding.py プロジェクト: zheewang/web3.py
def to_hex_with_size(value, bit_size):
    """
    Converts a value to hex with given bit_size:
    """
    return pad_hex(to_hex(value), bit_size)