Esempio n. 1
0
def close(
    auction_address,
    keystore: str,
    jsonrpc: str,
    gas: int,
    gas_price: int,
    nonce: int,
    auto_nonce: bool,
):
    web3 = connect_to_json_rpc(jsonrpc)
    private_key = retrieve_private_key(keystore)
    contracts = get_deployed_auction_contracts(web3, auction_address)

    nonce = get_nonce(web3=web3,
                      nonce=nonce,
                      auto_nonce=auto_nonce,
                      private_key=private_key)

    transaction_options = build_transaction_options(gas=gas,
                                                    gas_price=gas_price,
                                                    nonce=nonce)

    auction_close = contracts.auction.functions.closeAuction()

    send_function_call_transaction(
        auction_close,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
Esempio n. 2
0
def deploy_unw_eth(
    *,
    web3: Web3,
    transaction_options: Dict = None,
    private_key: bytes = None,
    exchange_address=None,
):
    if transaction_options is None:
        transaction_options = {}

    unw_eth = deploy(
        "UnwEth",
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )

    increase_transaction_options_nonce(transaction_options)

    if exchange_address is not None:
        if exchange_address is not None:
            function_call = unw_eth.functions.addAuthorizedAddress(exchange_address)
            send_function_call_transaction(
                function_call,
                web3=web3,
                transaction_options=transaction_options,
                private_key=private_key,
            )
            increase_transaction_options_nonce(transaction_options)

    return unw_eth
Esempio n. 3
0
def deploy_network(
    web3,
    name,
    symbol,
    decimals,
    expiration_time,
    fee_divisor=0,
    default_interest_rate=0,
    custom_interests=True,
    prevent_mediator_interests=False,
    exchange_address=None,
    currency_network_contract_name=None,
    transaction_options: Dict = None,
    private_key=None,
    authorized_addresses=None,
):
    if transaction_options is None:
        transaction_options = {}
    if authorized_addresses is None:
        authorized_addresses = []

    # CurrencyNetwork is the standard contract to deploy, If we're running
    # tests or trying to export data for testing the python implementation of
    # private functions, we may want deploy the TestCurrencyNetwork contract
    # instead.
    if currency_network_contract_name is None:
        currency_network_contract_name = "CurrencyNetwork"

    currency_network = deploy(
        currency_network_contract_name,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
    increase_transaction_options_nonce(transaction_options)

    if exchange_address is not None:
        authorized_addresses.append(exchange_address)

    init_function_call = currency_network.functions.init(
        name,
        symbol,
        decimals,
        fee_divisor,
        default_interest_rate,
        custom_interests,
        prevent_mediator_interests,
        expiration_time,
        authorized_addresses,
    )

    send_function_call_transaction(
        init_function_call,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
    increase_transaction_options_nonce(transaction_options)

    return currency_network
Esempio n. 4
0
def initialize_auction_contracts(
    *,
    web3,
    transaction_options=None,
    contracts: DeployedAuctionContracts,
    release_timestamp,
    private_key=None,
) -> None:
    if transaction_options is None:
        transaction_options = {}

    deposit_init = contracts.locker.functions.init(release_timestamp,
                                                   contracts.slasher.address,
                                                   contracts.auction.address)
    send_function_call_transaction(
        deposit_init,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
    increase_transaction_options_nonce(transaction_options)

    slasher_init = contracts.slasher.functions.init(contracts.locker.address)
    send_function_call_transaction(
        slasher_init,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
    increase_transaction_options_nonce(transaction_options)
def test_send_contract_call_set_nonce(test_contract, web3, account_keys):

    function_call = test_contract.functions.set(200)
    nonce = 1  # right nonce should be 0

    # This should just test, that the nonce is set
    # Apparently eth_tester raises a validation error if the nonce to high
    with pytest.raises(eth_utils.ValidationError):
        send_function_call_transaction(
            function_call,
            transaction_options={"nonce": nonce},
            web3=web3,
            private_key=account_keys[2],
        )
Esempio n. 6
0
def deploy_identity(
    web3, owner_address, chain_id=None, transaction_options: Dict = None
):
    if transaction_options is None:
        transaction_options = {}
    identity = deploy("Identity", web3=web3, transaction_options=transaction_options)
    increase_transaction_options_nonce(transaction_options)
    if chain_id is None:
        chain_id = get_chain_id(web3)
    function_call = identity.functions.init(owner_address, chain_id)
    send_function_call_transaction(
        function_call, web3=web3, transaction_options=transaction_options
    )
    increase_transaction_options_nonce(transaction_options)

    return identity
Esempio n. 7
0
def report_malicious_validator(
    web3,
    transaction_options,
    private_key,
    validator_set_contract_address,
    unsigned_block_header_one,
    signature_one,
    unsigned_block_header_two,
    signature_two,
):
    validator_set_contract = web3.eth.contract(
        abi=SIMPLE_REPORT_MALICIOUS_ABI,
        address=validator_set_contract_address)

    report_validator_call = validator_set_contract.functions.reportMaliciousValidator(
        unsigned_block_header_one,
        signature_one,
        unsigned_block_header_two,
        signature_two,
    )

    transaction_receipt = send_function_call_transaction(
        report_validator_call,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )

    return encode_hex(transaction_receipt.transactionHash)
def test_send_contract_call(test_contract, web3):

    function_call = test_contract.functions.set(200)

    receipt = send_function_call_transaction(function_call, web3=web3)

    assert receipt["status"]
    assert test_contract.functions.state().call() == 200
def test_send_contract_call_from_private_key(test_contract, web3, account_keys):

    function_call = test_contract.functions.set(200)

    receipt = send_function_call_transaction(
        function_call, web3=web3, private_key=account_keys[2]
    )

    assert receipt["status"]
    assert test_contract.functions.state().call() == 200
Esempio n. 10
0
def whitelist_addresses(
    auction_contract: Contract,
    whitelist: Sequence[str],
    *,
    batch_size,
    web3,
    transaction_options=None,
    private_key=None,
) -> int:
    """Add all not yet whitelisted addresses in `whitelist` to the whitelisted addresses in the auction contract.
    Returns the number of new whitelisted addresses"""

    if transaction_options is None:
        transaction_options = {}

    # only whitelist addresses that are not whitelisted yet
    filtered_whitelist = missing_whitelisted_addresses(auction_contract,
                                                       whitelist)

    assert batch_size > 0
    chunks = [
        filtered_whitelist[i:i + batch_size]
        for i in range(0, len(filtered_whitelist), batch_size)
    ]

    for chunk in chunks:
        assert len(chunk) <= batch_size

        add_to_whitelist_call = auction_contract.functions.addToWhitelist(
            chunk)

        send_function_call_transaction(
            add_to_whitelist_call,
            web3=web3,
            transaction_options=transaction_options,
            private_key=private_key,
        )

        increase_transaction_options_nonce(transaction_options)

    return len(filtered_whitelist)
Esempio n. 11
0
def initialize_validator_set_contract(
    *,
    web3,
    transaction_options=None,
    validator_set_contract,
    validators,
    validator_proxy_address,
    private_key=None
) -> None:
    if transaction_options is None:
        transaction_options = {}

    validator_init = validator_set_contract.functions.init(
        validators, validator_proxy_address
    )

    send_function_call_transaction(
        validator_init,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
Esempio n. 12
0
def deploy_proxied_identity(
    web3,
    factory_address,
    implementation_address,
    signature,
    *,
    transaction_options: Dict = None,
    private_key: bytes = None,
):
    if transaction_options is None:
        transaction_options = {}

    owner = recover_proxy_deployment_signature_owner(web3, factory_address,
                                                     implementation_address,
                                                     signature)

    interface = get_pinned_proxy_interface()
    initcode = build_initcode(
        contract_abi=interface["abi"],
        contract_bytecode=interface["bytecode"],
        constructor_args=[owner],
    )

    factory_interface = get_contract_interface("IdentityProxyFactory")
    factory = web3.eth.contract(address=factory_address,
                                abi=factory_interface["abi"])

    function_call = factory.functions.deployProxy(initcode,
                                                  implementation_address,
                                                  signature)
    receipt = send_function_call_transaction(
        function_call,
        web3=web3,
        transaction_options=transaction_options,
        private_key=private_key,
    )
    increase_transaction_options_nonce(transaction_options)

    deployment_event = factory.events.ProxyDeployment().processReceipt(receipt)
    proxy_address = deployment_event[0]["args"]["proxyAddress"]

    computed_proxy_address = build_create2_address(factory_address, initcode)
    assert (
        computed_proxy_address == proxy_address
    ), "The computed proxy address does not match the deployed address found via events"

    identity_interface = get_contract_interface("Identity")
    proxied_identity = web3.eth.contract(address=proxy_address,
                                         abi=identity_interface["abi"])
    return proxied_identity
def test_send_contract_call_with_transaction_options(test_contract, web3, account_keys):

    function_call = test_contract.functions.set(200)

    transaction_options = {"gas": 199999, "gasPrice": 99}

    receipt = send_function_call_transaction(
        function_call,
        web3=web3,
        transaction_options=transaction_options,
        private_key=account_keys[2],
    )

    transaction = web3.eth.getTransaction(receipt.transactionHash)

    for key, value in transaction_options.items():
        assert transaction[key] == value
Esempio n. 14
0
def initialize_auction_contracts(
    *,
    web3,
    transaction_options=None,
    contracts: DeployedAuctionContracts,
    release_timestamp,
    token_address=None,
    private_key=None,
) -> None:
    if transaction_options is None:
        transaction_options = {}

    if contracts.slasher is None:
        raise RuntimeError("Slasher contract not set")

    if not contracts.locker.functions.initialized().call():
        init_args: Tuple = (
            release_timestamp,
            contracts.slasher.address,
            contracts.auction.address,
        )
        if token_address is not None:
            init_args += (token_address, )

        deposit_init = contracts.locker.functions.init(*init_args)
        send_function_call_transaction(
            deposit_init,
            web3=web3,
            transaction_options=transaction_options,
            private_key=private_key,
        )
        increase_transaction_options_nonce(transaction_options)
    else:
        if (contracts.locker.functions.depositorsProxy().call() !=
                contracts.auction.address):
            raise ValueError(
                "Locker is already initialized but address of auction in locker and given auction contract do not match"
            )
        if contracts.locker.functions.slasher().call(
        ) != contracts.slasher.address:
            raise ValueError(
                "Locker is already initialized but address of slasher in locker and given slasher contract do not match"
            )

    if not contracts.slasher.functions.initialized().call():
        slasher_init = contracts.slasher.functions.init(
            contracts.locker.address)
        send_function_call_transaction(
            slasher_init,
            web3=web3,
            transaction_options=transaction_options,
            private_key=private_key,
        )
        increase_transaction_options_nonce(transaction_options)
    else:
        if (contracts.slasher.functions.depositContract().call() !=
                contracts.locker.address):
            raise ValueError(
                "Slasher is already initialized but address of locker in slasher and given locker contract do not match"
            )
    if contracts.auction.functions.depositLocker().call(
    ) != contracts.locker.address:
        raise ValueError(
            "Address of deposit locker in auction contract does not match with address of locker"
        )