def __init__(self,
web3: Web3,
contract: type,
dbsession: Session,
network_id,
from_block=0,
confirmation_count=1,
logger=logger,
registry=None):
assert isinstance(web3, Web3)
self.web3 = web3
self.client = get_rpc_client(web3)
self.last_block = from_block
self.network_id = network_id
self.event_map = self.build_event_map(contract)
self.contract = contract
self.dbsession = dbsession
self.tm = self.dbsession.transaction_manager
self.logger = logger
self.confirmation_count = confirmation_count
# For event notifications
self.registry = registry
def __init__(self, web3: Web3, callback: callback_type, from_block=0, logger=_logger):
"""Create a contract listener.
Callbacks look like:
.. code-block:: python
def cb(address, event_abi_signature, api_data)
pass
:param client: EthJsonRpc instance we use to connect to geth node
:param callback: Callable that's going to get called for every new event detected.
:param from_block: When to start iterating
:param logger: Optional
"""
assert isinstance(web3, Web3)
self.logger = _logger
self.web3 = web3
# web3 doesn't support filters yet
self.client = get_rpc_client(web3)
self.callback = callback
self.from_block = from_block
self.blockchain_timeout_seconds = 400
#: Mapping contract address -> ContractStatus
self.currently_monitored_contracts = {}
def __init__(self,
web3: Web3,
callback: callback_type,
from_block=0,
logger=_logger):
"""Create a contract listener.
Callbacks look like:
.. code-block:: python
def cb(address, event_abi_signature, api_data)
pass
:param client: EthJsonRpc instance we use to connect to geth node
:param callback: Callable that's going to get called for every new event detected.
:param from_block: When to start iterating
:param logger: Optional
"""
assert isinstance(web3, Web3)
self.logger = _logger
self.web3 = web3
# web3 doesn't support filters yet
self.client = get_rpc_client(web3)
self.callback = callback
self.from_block = from_block
self.blockchain_timeout_seconds = 400
#: Mapping contract address -> ContractStatus
self.currently_monitored_contracts = {}
def test_starter_token(dbsession, registry, eth_network_id, web3: Web3, eth_service: EthereumService, house_address, toybox):
"""See that a fresh user account is supplied with some play assets."""
with transaction.manager:
user = create_user(dbsession, registry)
setup_user_account(user)
# Let all the events completed
success, fail = eth_service.run_event_cycle()
assert success == 1
assert fail == 0
# We need another event cycle to process the initial asset transfers
with transaction.manager:
user = dbsession.query(User).first()
opid = user.user_data["starter_asset_txs"][0]["toybox"]
assert opid
wait_for_op_confirmations(eth_service, opid)
# Let the transfer come through
eth_service.run_event_cycle()
# Make sure we confirm the deposit
with transaction.manager:
user = dbsession.query(User).first()
user_depo = user.owned_crypto_operations.join(CryptoOperation).filter_by(operation_type=CryptoOperationType.deposit).first()
opid = user_depo.crypto_operation.id
wait_for_op_confirmations(eth_service, opid)
with transaction.manager:
# Sanity check our token contract posts us logs
user = dbsession.query(User).first()
client = get_rpc_client(web3)
asset = dbsession.query(Asset).get(toybox)
address = bin_to_eth_address(asset.external_id)
network = dbsession.query(AssetNetwork).get(eth_network_id)
user_address = UserCryptoAddress.get_default(user, network).address
house_address = dbsession.query(CryptoAddress).get(house_address)
house = bin_to_eth_address(house_address.address)
token = Token.get(web3, address)
# Check we correctly resolved low level logs
token_logs = client.get_logs(from_block=0, address=[address])
wallet_logs = client.get_logs(from_block=0, address=[house])
assert len(token_logs) > 0
assert len(wallet_logs) > 0
# Check contract state matches
assert token.contract.call().balanceOf(house) == 9990
assert token.contract.call().balanceOf(bin_to_eth_address(user_address.address)) == 10
# Check our internal book keeping matches
assert house_address.get_account(asset).account.get_balance() == 9990
assert user_address.get_account(asset).account.get_balance() == 10
def test_starter_eth(dbsession, registry, eth_network_id, web3: Web3,
eth_service: EthereumService, house_address, starter_eth):
"""Test the user gets some starter ETH when signing up."""
with transaction.manager:
user = create_user(dbsession, registry)
setup_user_account(user, do_mainnet=True)
# Let all the events completed
success, fail = eth_service.run_event_cycle()
assert success >= 1
assert fail == 0
# When op is confirmed, the user account is correctly credited
with transaction.manager:
user = dbsession.query(User).first()
txid = user.user_data["starter_asset_txs"][0]["eth"]
confirm_transaction(web3, txid)
# Let the transfer come through
eth_service.run_event_cycle()
with transaction.manager:
user = dbsession.query(User).first()
client = get_rpc_client(web3)
asset = get_ether_asset(dbsession)
ua = user.owned_crypto_addresses.first()
address = bin_to_eth_address(ua.address.address)
# Sanity check we get events from starter deposit
logs = client.get_logs(from_block=0, address=[address])
ops = list(user.owned_crypto_operations)
# The event was processed on log level
assert len(logs) == 1
# The last user operation is deposit
depo = ops[-1]
assert isinstance(depo.crypto_operation, CryptoAddressDeposit)
opid = depo.crypto_operation.id
# Wait deposit to confirm
wait_for_op_confirmations(eth_service, opid)
with transaction.manager:
# User ETH balance is expected
asset = get_ether_asset(dbsession)
user = dbsession.query(User).first()
ua = user.owned_crypto_addresses.first()
caccout = ua.address.get_account(asset)
assert caccout.account.get_balance() == Decimal("0.1")
def test_starter_eth(dbsession, registry, eth_network_id, web3: Web3, eth_service: EthereumService, house_address, starter_eth):
"""Test the user gets some starter ETH when signing up."""
with transaction.manager:
user = create_user(dbsession, registry)
setup_user_account(user)
# Let all the events completed
success, fail = eth_service.run_event_cycle()
assert success >= 1
assert fail == 0
# When op is confirmed, the user account is correctly credited
with transaction.manager:
user = dbsession.query(User).first()
txid = user.user_data["starter_asset_txs"][0]["eth"]
confirm_transaction(web3, txid)
# Let the transfer come through
eth_service.run_event_cycle()
with transaction.manager:
user = dbsession.query(User).first()
client = get_rpc_client(web3)
asset = get_ether_asset(dbsession)
ua = user.owned_crypto_addresses.first()
address = bin_to_eth_address(ua.address.address)
# Sanity check we get events from starter deposit
logs = client.get_logs(from_block=0, address=[address])
ops = list(user.owned_crypto_operations)
# The event was processed on log level
assert len(logs) == 1
# The last user operation is deposit
depo = ops[-1]
assert isinstance(depo.crypto_operation, CryptoAddressDeposit)
opid = depo.crypto_operation.id
# Wait deposit to confirm
wait_for_op_confirmations(eth_service, opid)
with transaction.manager:
# User ETH balance is expected
asset = get_ether_asset(dbsession)
user = dbsession.query(User).first()
ua = user.owned_crypto_addresses.first()
caccout = ua.address.get_account(asset)
assert caccout.account.get_balance() == Decimal("0.1")
def __init__(self, web3: Web3, dbsession: Session, network_id, registry, logger=logger):
assert isinstance(web3, Web3)
self.web3 = web3
# web3 doesn't support filters yet
self.client = get_rpc_client(web3)
self.network_id = network_id
self.dbsession = dbsession
self.tm = self.dbsession.transaction_manager
self.logger = logger
self.registry = registry
def __init__(self, web3: Web3, dbsession: Session, network_id, registry, logger=logger):
assert isinstance(web3, Web3)
self.web3 = web3
# web3 doesn't support filters yet
self.client = get_rpc_client(web3)
self.network_id = network_id
self.dbsession = dbsession
self.tm = self.dbsession.transaction_manager
self.logger = logger
self.registry = registry
def __init__(self, web3: Web3, contract: type, dbsession: Session, network_id, from_block=0, confirmation_count=1, logger=logger, registry=None):
assert isinstance(web3, Web3)
self.web3 = web3
self.client = get_rpc_client(web3)
self.last_block = from_block
self.network_id = network_id
self.event_map = self.build_event_map(contract)
self.contract = contract
self.dbsession = dbsession
self.tm = self.dbsession.transaction_manager
self.logger = logger
self.confirmation_count = confirmation_count
# For event notifications
self.registry = registry
def test_starter_token(dbsession, registry, eth_network_id, web3: Web3,
eth_service: EthereumService, house_address, toybox):
"""See that a fresh user account is supplied with some play assets."""
with transaction.manager:
user = create_user(dbsession, registry)
setup_user_account(user, do_mainnet=True)
# Let all the events completed
success, fail = eth_service.run_event_cycle()
assert success == 1
assert fail == 0
# We need another event cycle to process the initial asset transfers
with transaction.manager:
user = dbsession.query(User).first()
opid = user.user_data["starter_asset_txs"][0]["toybox"]
assert opid
wait_for_op_confirmations(eth_service, opid)
# Let the transfer come through
eth_service.run_event_cycle()
# Make sure we confirm the deposit
with transaction.manager:
user = dbsession.query(User).first()
user_depo = user.owned_crypto_operations.join(
CryptoOperation).filter_by(
operation_type=CryptoOperationType.deposit).first()
opid = user_depo.crypto_operation.id
wait_for_op_confirmations(eth_service, opid)
with transaction.manager:
# Sanity check our token contract posts us logs
user = dbsession.query(User).first()
client = get_rpc_client(web3)
asset = dbsession.query(Asset).get(toybox)
address = bin_to_eth_address(asset.external_id)
network = dbsession.query(AssetNetwork).get(eth_network_id)
user_address = UserCryptoAddress.get_default(user, network).address
house_address = dbsession.query(CryptoAddress).get(house_address)
house = bin_to_eth_address(house_address.address)
token = Token.get(web3, address)
# Check we correctly resolved low level logs
token_logs = client.get_logs(from_block=0, address=[address])
wallet_logs = client.get_logs(from_block=0, address=[house])
assert len(token_logs) > 0
assert len(wallet_logs) > 0
# Check contract state matches
assert token.contract.call().balanceOf(house) == 9990
assert token.contract.call().balanceOf(
bin_to_eth_address(user_address.address)) == 10
# Check our internal book keeping matches
assert house_address.get_account(asset).account.get_balance() == 9990
assert user_address.get_account(asset).account.get_balance() == 10
