Rehabilitate transfer, approve

Signed-off-by: nolash <dev@holbrook.no>
2021-03-29 13:27:53 +00:00
parent 299385f320
commit b65ab8a0ca
222 changed files with 3272 additions and 809800 deletions
--- a/apps/cic-eth/tests/task/api/test_admin.py
+++ b/apps/cic-eth/tests/task/api/test_admin.py
@@ -0,0 +1,294 @@
+# standard imports
+import os
+import logging
+
+# external imports
+import celery
+import pytest
+from chainlib.eth.tx import (
+        unpack,
+        TxFormat,
+        )
+from chainlib.eth.nonce import RPCNonceOracle
+from chainlib.eth.gas import Gas
+from chainlib.eth.address import to_checksum_address
+from hexathon import (
+        strip_0x,
+        add_0x,
+        )
+
+# local imports
+from cic_eth.api import AdminApi
+from cic_eth.db.models.role import AccountRole
+from cic_eth.db.models.otx import Otx
+from cic_eth.db.models.tx import TxCache
+from cic_eth.db.enum import (
+        StatusEnum,
+        StatusBits,
+        status_str,
+        LockEnum,
+        )
+from cic_eth.error import InitializationError
+from cic_eth.eth.tx import (
+        cache_gas_data,
+        )
+#from cic_eth.eth.gas import cache_gas_tx
+from cic_eth.queue.tx import (
+        create as queue_create,
+        get_tx,
+        )
+
+logg = logging.getLogger()
+
+
+#def test_resend_inplace(
+#    default_chain_spec,
+#    init_database,
+#    init_w3,
+#    celery_session_worker,
+#    ):
+#    
+#    chain_str = str(default_chain_spec)
+#    c = RpcClient(default_chain_spec)
+#    
+#    sigs = []
+#
+#    gas_provider = c.gas_provider()
+#
+#    s_nonce = celery.signature(
+#        'cic_eth.eth.tx.reserve_nonce',
+#        [
+#            init_w3.eth.accounts[0],
+#            gas_provider,
+#            ],
+#        queue=None,
+#        )
+#    s_refill = celery.signature(
+#        'cic_eth.eth.tx.refill_gas',
+#        [
+#            chain_str,
+#            ],
+#        queue=None,
+#            )
+#    s_nonce.link(s_refill)
+#    t = s_nonce.apply_async()
+#    t.get()
+#    for r in t.collect():
+#        pass
+#    assert t.successful()
+#
+#    q = init_database.query(Otx)
+#    q = q.join(TxCache)
+#    q = q.filter(TxCache.recipient==init_w3.eth.accounts[0])
+#    o = q.first()
+#    tx_raw = o.signed_tx
+#
+#    tx_dict = unpack_signed_raw_tx(bytes.fromhex(tx_raw[2:]), default_chain_spec.chain_id())
+#    gas_price_before = tx_dict['gasPrice'] 
+#
+#    s = celery.signature(
+#        'cic_eth.admin.ctrl.lock_send',
+#        [
+#            chain_str,
+#            init_w3.eth.accounts[0],
+#            ],
+#        queue=None,
+#            )
+#    t = s.apply_async()
+#    t.get()
+#    assert t.successful()
+#
+#    api = AdminApi(c, queue=None)
+#    t = api.resend(tx_dict['hash'], chain_str, unlock=True)
+#    t.get()
+#    i = 0
+#    tx_hash_new_hex = None
+#    for r in t.collect():
+#        tx_hash_new_hex = r[1]
+#    assert t.successful()
+#  
+#    tx_raw_new = get_tx(tx_hash_new_hex) 
+#    logg.debug('get {}'.format(tx_raw_new))
+#    tx_dict_new = unpack_signed_raw_tx(bytes.fromhex(tx_raw_new['signed_tx'][2:]), default_chain_spec.chain_id())
+#    assert tx_hash_new_hex != tx_dict['hash']
+#    assert tx_dict_new['gasPrice'] > gas_price_before
+#
+#    tx_dict_after = get_tx(tx_dict['hash'])
+#
+#    logg.debug('logggg {}'.format(status_str(tx_dict_after['status'])))
+#    assert tx_dict_after['status'] & StatusBits.MANUAL
+
+
+#def test_check_fix_nonce(
+#    default_chain_spec,
+#    init_database,
+#    init_eth_account_roles,
+#    init_w3,
+#    eth_empty_accounts,
+#    celery_session_worker,
+#    ):
+#
+#    chain_str = str(default_chain_spec)
+#    
+#    sigs = []
+#    for i in range(5):
+#        s = celery.signature(
+#            'cic_eth.eth.tx.refill_gas',
+#            [
+#                eth_empty_accounts[i],
+#                chain_str,
+#                ],
+#            queue=None,
+#                )
+#        sigs.append(s)
+#
+#    t = celery.group(sigs)()
+#    txs = t.get()
+#    assert t.successful()
+#
+#    tx_hash = web3.Web3.keccak(hexstr=txs[2])
+#    c = RpcClient(default_chain_spec)
+#    api = AdminApi(c, queue=None)
+#    address = init_eth_account_roles['eth_account_gas_provider']
+#    nonce_spec = api.check_nonce(address)
+#    assert nonce_spec['nonce']['network'] == 0
+#    assert nonce_spec['nonce']['queue'] == 4
+#    assert nonce_spec['nonce']['blocking'] == None
+#
+#    s_set = celery.signature(
+#            'cic_eth.queue.tx.set_rejected',
+#            [
+#                tx_hash.hex(),
+#                ],
+#            queue=None,
+#            )
+#    t = s_set.apply_async()
+#    t.get()
+#    t.collect()
+#    assert t.successful()
+#
+#
+#    nonce_spec = api.check_nonce(address)
+#    assert nonce_spec['nonce']['blocking'] == 2
+#    assert nonce_spec['tx']['blocking'] == tx_hash.hex()
+#
+#    t = api.fix_nonce(address, nonce_spec['nonce']['blocking'])
+#    t.get()
+#    t.collect()
+#    assert t.successful()
+#
+#    for tx in txs[3:]:
+#        tx_hash = web3.Web3.keccak(hexstr=tx)
+#        tx_dict = get_tx(tx_hash.hex())
+#        assert tx_dict['status'] == StatusEnum.OVERRIDDEN
+#
+#
+
+
+def test_have_account(
+    default_chain_spec,
+    custodial_roles,
+    init_celery_tasks,
+    eth_rpc,
+    celery_session_worker,
+    ):
+
+    api = AdminApi(None, queue=None)
+    t = api.have_account(custodial_roles['ALICE'], default_chain_spec)
+    assert t.get() != None 
+
+    bogus_address = add_0x(to_checksum_address(os.urandom(20).hex()))
+    api = AdminApi(None, queue=None)
+    t = api.have_account(bogus_address, default_chain_spec)
+    assert t.get() == None
+
+
+def test_locking(
+    default_chain_spec,
+    init_database,
+    agent_roles,
+    init_celery_tasks,
+    celery_session_worker,
+    ):
+
+    api = AdminApi(None, queue=None)
+
+    t = api.lock(default_chain_spec, agent_roles['ALICE'], LockEnum.SEND)
+    t.get()
+    t = api.get_lock()
+    r = t.get()
+    assert len(r) == 1
+
+    t = api.unlock(default_chain_spec, agent_roles['ALICE'], LockEnum.SEND)
+    t.get()
+    t = api.get_lock()
+    r = t.get()
+    assert len(r) == 0
+
+
+def test_tag_account(
+    default_chain_spec,
+    init_database,
+    agent_roles,
+    eth_rpc,
+    init_celery_tasks,
+    celery_session_worker,
+    ):
+
+    api = AdminApi(eth_rpc, queue=None)
+
+    t = api.tag_account('foo', agent_roles['ALICE'], default_chain_spec)
+    t.get()
+    t = api.tag_account('bar', agent_roles['BOB'], default_chain_spec)
+    t.get()
+    t = api.tag_account('bar', agent_roles['CAROL'], default_chain_spec)
+    t.get()
+
+    assert AccountRole.get_address('foo', init_database) == agent_roles['ALICE']
+    assert AccountRole.get_address('bar', init_database) == agent_roles['CAROL']
+
+
+#def test_ready(
+#    init_database,
+#    agent_roles,
+#    eth_rpc,
+#    ):
+#
+#    api = AdminApi(eth_rpc)
+#   
+#    with pytest.raises(InitializationError):
+#        api.ready()
+#
+#    bogus_account = os.urandom(20)
+#    bogus_account_hex = '0x' + bogus_account.hex()
+#
+#    api.tag_account('ETH_GAS_PROVIDER_ADDRESS', web3.Web3.toChecksumAddress(bogus_account_hex))
+#    with pytest.raises(KeyError):
+#        api.ready()
+#
+#    api.tag_account('ETH_GAS_PROVIDER_ADDRESS', eth_empty_accounts[0])
+#    api.ready()
+
+
+def test_tx(
+    default_chain_spec,
+    cic_registry,
+    init_database,
+    eth_rpc,
+    eth_signer,
+    agent_roles,
+    contract_roles,
+    celery_session_worker,
+    ):
+
+    chain_id = default_chain_spec.chain_id()
+    nonce_oracle = RPCNonceOracle(agent_roles['ALICE'], eth_rpc)
+    c = Gas(signer=eth_signer, nonce_oracle=nonce_oracle, chain_id=chain_id)
+    (tx_hash_hex, tx_signed_raw_hex) = c.create(agent_roles['ALICE'], agent_roles['BOB'], 1024, tx_format=TxFormat.RLP_SIGNED)
+    tx = unpack(bytes.fromhex(strip_0x(tx_signed_raw_hex)), chain_id)
+    queue_create(tx['nonce'], agent_roles['ALICE'], tx_hash_hex, tx_signed_raw_hex, default_chain_spec, session=init_database)
+    cache_gas_data(tx_hash_hex, tx_signed_raw_hex, default_chain_spec.asdict())
+
+    api = AdminApi(eth_rpc, queue=None, call_address=contract_roles['DEFAULT'])
+    tx = api.tx(default_chain_spec, tx_hash=tx_hash_hex)
+    logg.warning('code missing to verify tx contents {}'.format(tx))
--- a/apps/cic-eth/tests/task/api/test_app.py
+++ b/apps/cic-eth/tests/task/api/test_app.py
@@ -0,0 +1,121 @@
+# standard imports
+import os
+import logging
+import time
+
+# external imports
+import pytest
+import celery
+from cic_eth_registry.erc20 import ERC20Token
+from chainlib.chain import ChainSpec
+
+# local imports
+from cic_eth.api import Api
+
+logg = logging.getLogger(__name__)
+
+
+def test_account_api(
+        default_chain_spec,
+        init_database,
+        init_eth_rpc,
+        account_registry,
+        custodial_roles,
+        celery_session_worker,
+        ):
+    api = Api(str(default_chain_spec), callback_param='accounts', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.create_account('', register=False)
+    t.get_leaf()
+    assert t.successful()
+
+
+def test_transfer_api(
+        default_chain_spec,
+        eth_rpc,
+        init_database,
+        foo_token,
+        custodial_roles,
+        agent_roles,
+        cic_registry,
+        register_tokens,
+        celery_session_worker,
+        ):
+
+    #token = CICRegistry.get_address(default_chain_spec, bancor_tokens[0])
+    foo_token_cache = ERC20Token(eth_rpc, foo_token)
+
+    api = Api(str(default_chain_spec), callback_param='transfer', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.transfer(custodial_roles['FOO_TOKEN_GIFTER'], agent_roles['ALICE'], 1024, foo_token_cache.symbol)
+    t.get_leaf()
+    assert t.successful()
+
+
+@pytest.mark.skip()
+def test_convert_api(
+        default_chain_spec,
+        init_w3,
+        cic_registry,
+        init_database,
+        foo_token,
+        bar_token,
+        celery_session_worker,
+        ):
+    
+    token_alice = CICRegistry.get_address(default_chain_spec, bancor_tokens[0])
+    token_bob = CICRegistry.get_address(default_chain_spec, bancor_tokens[1])
+
+    api = Api(str(default_chain_spec), callback_param='convert', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.convert(custodial_roles['FOO_TOKEN_GIFTER'], 110, 100, foo_token_cache.symbol, bar_token_cache.symbol)
+    t.get_leaf()
+    assert t.successful()
+
+
+@pytest.mark.skip()
+def test_convert_transfer_api(
+        default_chain_spec,
+        init_w3,
+        cic_registry,
+        init_database,
+        bancor_registry,
+        bancor_tokens,
+        celery_session_worker,
+        ):
+
+    token_alice = CICRegistry.get_address(default_chain_spec, bancor_tokens[0])
+    token_bob = CICRegistry.get_address(default_chain_spec, bancor_tokens[1])
+
+    api = Api(str(default_chain_spec), callback_param='convert_transfer', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.convert_transfer(init_w3.eth.accounts[2], init_w3.eth.accounts[4], 110, 100, token_alice.symbol(), token_bob.symbol())
+    t.get()
+    for r in t.collect():
+        print(r)
+    assert t.successful()
+
+
+def test_refill_gas(
+        default_chain_spec,
+        init_database,
+        eth_empty_accounts,
+        init_eth_rpc,
+        custodial_roles,
+        celery_session_worker,
+        ):
+
+    api = Api(str(default_chain_spec), callback_param='refill_gas', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.refill_gas(eth_empty_accounts[0])
+    t.get()
+    for r in t.collect():
+        print(r)
+    assert t.successful()
+
+
+def test_ping(
+        default_chain_spec,
+        celery_session_worker,
+        ):
+    api = Api(str(default_chain_spec), callback_param='ping', callback_task='cic_eth.callbacks.noop.noop', queue=None)
+    t = api.ping('pong')
+    t.get()
+    for r in t.collect():
+        print(r)
+    assert t.successful()
--- a/apps/cic-eth/tests/task/api/test_balance.py
+++ b/apps/cic-eth/tests/task/api/test_balance.py
@@ -0,0 +1,55 @@
+# standard imports
+import os
+import logging
+
+# external imports
+from chainlib.eth.address import to_checksum_address
+
+# local imports
+from cic_eth.api.api_task import Api
+
+logg = logging.getLogger()
+
+def test_balance_simple_api(
+        default_chain_spec,
+        init_database,
+        cic_registry,
+        foo_token,
+        register_tokens,
+        api,
+        celery_session_worker,
+    ):
+
+    chain_str = str(default_chain_spec)
+
+    a = to_checksum_address('0x' + os.urandom(20).hex())
+    t = api.balance(a, 'FOO', include_pending=False)
+    r = t.get_leaf()
+    assert t.successful()
+    logg.debug(r)
+
+    assert r[0].get('balance_network') != None
+
+
+def test_balance_complex_api(
+        default_chain_spec,
+        init_database,
+        cic_registry,
+        foo_token,
+        register_tokens,
+        api,
+        celery_session_worker,
+    ):
+
+    chain_str = str(default_chain_spec)
+
+    a = to_checksum_address('0x' + os.urandom(20).hex())
+    t = api.balance(a, 'FOO', include_pending=True)
+    r = t.get_leaf()
+    assert t.successful()
+    logg.debug(r)
+
+    assert r[0].get('balance_incoming') != None
+    assert r[0].get('balance_outgoing') != None
+    assert r[0].get('balance_network') != None
+
--- a/apps/cic-eth/tests/task/api/test_list.py
+++ b/apps/cic-eth/tests/task/api/test_list.py
@@ -0,0 +1,120 @@
+# standard imports
+import logging
+
+# local imports
+from chainlib.eth.nonce import RPCNonceOracle
+from chainlib.eth.erc20 import ERC20
+from chainlib.eth.tx import receipt
+from cic_eth.api.api_task import Api
+from tests.mock.filter import (
+        block_filter,
+        tx_filter,
+        )
+from cic_eth.db.models.nonce import (
+        Nonce,
+        NonceReservation,
+        )
+
+logg = logging.getLogger()
+
+
+def test_list_tx(
+        default_chain_spec,
+        init_database,
+        cic_registry,
+        eth_rpc,
+        eth_signer,
+        custodial_roles,
+        agent_roles,
+        foo_token,
+        register_tokens,
+        init_eth_tester,
+        celery_session_worker,
+        ):
+
+    chain_id = default_chain_spec.chain_id()
+
+    tx_hashes = []
+
+    # external tx
+    nonce_oracle = RPCNonceOracle(custodial_roles['FOO_TOKEN_GIFTER'], eth_rpc)
+    nonce = nonce_oracle.get_nonce()
+    
+    q = init_database.query(Nonce)
+    q = q.filter(Nonce.address_hex==agent_roles['ALICE'])
+    o = q.first()
+    o.nonce = nonce
+    init_database.add(o)
+    init_database.commit()
+
+    # TODO: implement cachenonceoracle instead, this is useless
+    # external tx one
+    Nonce.next(custodial_roles['FOO_TOKEN_GIFTER'], 'foo', session=init_database)
+    init_database.commit()
+
+    init_eth_tester.mine_blocks(13)
+    c = ERC20(signer=eth_signer, nonce_oracle=nonce_oracle, chain_id=chain_id)
+    (tx_hash_hex, o) = c.transfer(foo_token, custodial_roles['FOO_TOKEN_GIFTER'], agent_roles['ALICE'], 1024)
+    eth_rpc.do(o)
+    o = receipt(tx_hash_hex)
+    r = eth_rpc.do(o)
+    assert r['status'] == 1
+    a = r['block_number']
+    block_filter.add(a.to_bytes(4, 'big'))
+
+    a = r['block_number'] + r['transaction_index']
+    tx_filter.add(a.to_bytes(4, 'big'))
+
+    tx_hashes.append(tx_hash_hex)
+
+    # external tx two
+    Nonce.next(agent_roles['ALICE'], 'foo', session=init_database)
+    init_database.commit()
+
+    init_eth_tester.mine_blocks(13)
+    nonce_oracle = RPCNonceOracle(agent_roles['ALICE'], eth_rpc)
+    c = ERC20(signer=eth_signer, nonce_oracle=nonce_oracle, chain_id=chain_id)
+    (tx_hash_hex, o) = c.transfer(foo_token, agent_roles['ALICE'], agent_roles['BOB'], 256)
+    eth_rpc.do(o)
+    o = receipt(tx_hash_hex)
+    r = eth_rpc.do(o)
+    assert r['status'] == 1
+    a = r['block_number']
+    block_filter.add(a.to_bytes(4, 'big'))
+
+    a = r['block_number'] + r['transaction_index']
+    tx_filter.add(a.to_bytes(4, 'big'))
+
+    tx_hashes.append(tx_hash_hex)
+
+    init_eth_tester.mine_blocks(28)
+
+    # custodial tx 1
+    api = Api(str(default_chain_spec), queue=None)
+    t = api.transfer(agent_roles['ALICE'], agent_roles['CAROL'], 64, 'FOO') #, 'blinky')
+    r = t.get_leaf()
+    assert t.successful()
+    tx_hashes.append(r)
+
+    # custodial tx 2
+    api = Api(str(default_chain_spec), queue=None)
+    t = api.transfer(agent_roles['ALICE'], agent_roles['DAVE'], 16, 'FOO') #, 'blinky')
+    r = t.get_leaf()
+    assert t.successful()
+    tx_hashes.append(r)
+
+    logg.debug('r {}'.format(r))
+
+    # test the api
+    t = api.list(agent_roles['ALICE'], external_task='tests.mock.filter.filter')
+    r = t.get_leaf()
+    assert t.successful()
+
+
+    assert len(r) == 3
+    logg.debug('rrrr {}'.format(r))
+
+    for tx in r:
+        logg.debug('have tx {}'.format(tx))
+        tx_hashes.remove(tx['hash'])
+    assert len(tx_hashes) == 1