def get_contract_proxy(self, contract_name: str, address: str) -> Contract:
"""Get web3.Contract to interact directly with the network"""
abi_data = self.abi[contract_name]
contract_class = Contract.factory(
web3=self.web3,
abi=abi_data["abi"],
bytecode=abi_data["bytecode"],
bytecode_runtime=abi_data["bytecode_runtime"],
)
return contract_class(address=to_checksum_address(address))
def deploy_contract(self, contract_name: str, abi: dict, note: str, constructor_args=None) -> _PreparedTransaction:
"""Deploys a contract."""
if not constructor_args:
constructor_args = {}
abi_data = abi[contract_name]
assert "source" in abi_data, "We need to have special postprocessed ABI data bundle, as we need the contract source code for EtherScan verification"
contract_class = Contract.factory(
web3=self.web3,
abi=abi_data["abi"],
bytecode=abi_data["bytecode"],
bytecode_runtime=abi_data["bytecode_runtime"],
)
broadcast_account = self.get_or_create_broadcast_account()
next_nonce = self.get_next_nonce()
# Creates a dict for signing
tx_data = self.generate_tx_data(next_nonce, contract_tx=True)
constructed_txn = contract_class.constructor(**constructor_args).buildTransaction(tx_data)
constructor_arguments = get_constructor_arguments(contract_class, kwargs=constructor_args)
derived_contract_address = mk_contract_address(self.address, next_nonce)
derived_contract_address = to_checksum_address(derived_contract_address.lower())
constructed_txn["to"] = "" # Otherwise database serializer complains about bytes string
tx = self.allocate_transaction(
broadcast_account=broadcast_account,
receiver=None,
contract_address=derived_contract_address,
contract_deployment=True,
nonce=next_nonce,
note=note,
unsigned_payload=constructed_txn,
gas_price=self.gas_price,
gas_limit=self.gas_limit,
)
self.dbsession.flush() # Populate other_data
tx.abi = abi_data
tx.constructor_arguments = constructor_arguments
assert tx.compiler_version
assert tx.flattened_source_code
return tx
def deploy_contract(self,
contract_name: str,
abi: dict,
note: str,
constructor_args=None) -> _PreparedTransaction:
"""Deploys a contract."""
if not constructor_args:
constructor_args = {}
abi_data = abi[contract_name]
contract_class = Contract.factory(
web3=self.web3,
abi=abi_data["abi"],
bytecode=abi_data["bytecode"],
bytecode_runtime=abi_data["bytecode_runtime"],
)
broadcast_account = self.get_or_create_broadcast_account()
next_nonce = self.get_next_nonce()
# Creates a dict for signing
tx_data = self.generate_tx_data(next_nonce, contract_tx=True)
constructed_txn = contract_class.constructor(
**constructor_args).buildTransaction(tx_data)
derived_contract_address = mk_contract_address(self.address,
next_nonce)
derived_contract_address = to_checksum_address(
derived_contract_address.lower())
constructed_txn[
"to"] = "" # Otherwise database serializer complains about bytes string
tx = self.allocate_transaction(
broadcast_account=broadcast_account,
receiver=None,
contract_address=derived_contract_address,
contract_deployment=True,
nonce=next_nonce,
note=note,
unsigned_payload=constructed_txn,
gas_price=self.gas_price,
gas_limit=self.gas_limit,
)
self.dbsession.flush()
return tx
def token_contract(sample_token, web3) -> Contract:
"""Proxied ABI to the deployed SecurityToken token contract."""
contract_name = "SecurityToken"
abi = get_abi(None)
abi_data = abi[contract_name]
contract_class = Contract.factory(
web3=web3,
abi=abi_data["abi"],
bytecode=abi_data["bytecode"],
bytecode_runtime=abi_data["bytecode_runtime"],
)
return contract_class(address=sample_token)
def factory(cls, *args, **kwargs):
return compose(cls, Contract.factory(*args, **kwargs))
def deploy_contract(web3: Web3,
abi_data: dict,
gas=1500000,
timeout=60.0,
constructor_arguments: Optional[list] = None,
from_account=None) -> Tuple[Contract, str]:
"""Deploys a single contract using Web3 client.
:param web3: Web3 client instance
:param contract_definition: Dictionary of describing the contract interface,
as read from ``contracts.json`` Contains
:param gas: Max gas
:param timeout: How many seconds to wait the transaction to
confirm to get the contract address.
:param constructor_arguments: Arguments passed to the smart contract
constructor. Automatically encoded through ABI signature.
:param from_account: Geth account that's balance is used for deployment.
By default, the gas is spent from Web3 coinbase account. Account must be unlocked.
:return: Tuple containing Contract proxy object and the transaction hash where it was deployed
:raise web3.utils.compat.Timeout: If we can't get our contract in a block within given timeout
"""
# Check we are passed valid contract definition
assert "abi" in abi_data, \
"Please pass a valid contract definition dictionary, got {}".format(abi_data.keys())
assert len(abi_data["bytecode"]
) > 8, "Contract did not have properly compiled code payload"
contract_class = Contract.factory(
web3=web3,
abi=abi_data["abi"],
bytecode=abi_data["bytecode"],
bytecode_runtime=abi_data["bytecode_runtime"],
)
if not from_account:
from_account = web3.eth.coinbase
# Set transaction parameters
transaction = {
"gas": gas,
"from": from_account,
}
# Call web3 to deploy the contract
txn_hash = contract_class.deploy(transaction, constructor_arguments)
# Wait until we get confirmation and address
address = get_contract_address_from_txn(web3, txn_hash, timeout=timeout)
# Create Contract proxy object
contract = contract_class(address=address, )
return contract, txn_hash
