Exemple #1
0
    def test_private_without_stark_private_key(self):
        # Generate STARK keys and Ethhereum account.
        api_private_key = generate_private_key_hex_unsafe()
        stark_private_key = generate_private_key_hex_unsafe()
        eth_account = Web3(None).eth.account.create()

        # Get public keys.
        api_public_key = private_key_to_public_hex(api_private_key)
        stark_public_key = private_key_to_public_hex(stark_private_key)

        # Onboard the user.
        Client(
            host=API_HOST,
            eth_private_key=eth_account.key,
        ).onboarding.create_user(
            api_public_key=api_public_key,
            stark_public_key=stark_public_key,
        )

        # Create a second client WITHOUT eth_private_key or stark_private_key.
        client = Client(
            host=API_HOST,
            api_private_key=api_private_key,
        )

        # Create a test deposit.
        client.private.create_test_deposit(
            from_address=eth_account.address,
            credit_amount='200',
        )

        # Get the primary account.
        get_account_result = client.private.get_account(
            ethereum_address=eth_account.address, )
        account = get_account_result['account']

        # Sign a withdrawal.
        client_id = random_client_id()
        expiration = epoch_seconds_to_iso(time.time() + 60)
        signable_withdrawal = SignableWithdrawal(
            position_id=account['positionId'],
            client_id=client_id,
            human_amount='1',
            expiration_epoch_seconds=iso_to_epoch_seconds(expiration),
        )
        signature = signable_withdrawal.sign(stark_private_key)

        # Initiate a withdrawal.
        client.private.create_withdrawal(
            position_id=account['positionId'],
            amount='1',
            asset=constants.ASSET_USDC,
            to_address=eth_account.address,
            expiration=expiration,
            client_id=client_id,
            signature=signature,
        )
Exemple #2
0
    def test_onboard_with_web3_provider(self):
        # Generate private keys.
        api_private_key = generate_private_key_hex_unsafe()
        stark_private_key = generate_private_key_hex_unsafe()

        # Get public keys.
        api_public_key = private_key_to_public_hex(api_private_key)
        stark_public_key = private_key_to_public_hex(stark_private_key)

        # Get account address from local Ethereum node.
        ethereum_address = Web3().eth.accounts[0]

        # Create client WITHOUT any private keys.
        client = Client(
            host=API_HOST,
            web3_provider=Web3.HTTPProvider('http://localhost:8545'),
        )

        # Onboard the user.
        try:
            client.onboarding.create_user(
                ethereum_address=ethereum_address,
                stark_public_key=stark_public_key,
                api_public_key=api_public_key,
            )

        # If the Ethereum address was already onboarded, ignore the error.
        except DydxApiError:
            pass

        # Register and then revoke a second API key.
        api_private_key_2 = generate_private_key_hex_unsafe()
        api_public_key_2 = private_key_to_public_hex(api_private_key_2)
        client.api_keys.register_api_key(
            api_public_key=api_public_key_2,
            ethereum_address=ethereum_address,
        )
        client.api_keys.get_api_keys(ethereum_address=ethereum_address, )
        client.api_keys.delete_api_key(
            api_public_key=api_public_key_2,
            ethereum_address=ethereum_address,
        )
Exemple #3
0
    def test_onboard_with_web3_default_account(self):
        # Generate private keys.
        api_private_key = generate_private_key_hex_unsafe()
        stark_private_key = generate_private_key_hex_unsafe()

        # Get public keys.
        api_public_key = private_key_to_public_hex(api_private_key)
        stark_public_key = private_key_to_public_hex(stark_private_key)

        # Connect to local Ethereum node.
        web3 = Web3()
        web3.eth.defaultAccount = web3.eth.accounts[1]

        # Create client WITHOUT any private keys.
        client = Client(
            host=API_HOST,
            web3=web3,
        )

        # Onboard the user.
        try:
            client.onboarding.create_user(
                stark_public_key=stark_public_key,
                api_public_key=api_public_key,
            )

        # If the Ethereum address was already onboarded, ignore the error.
        except DydxApiError:
            pass

        # Register and then revoke a second API key.
        api_private_key_2 = generate_private_key_hex_unsafe()
        api_public_key_2 = private_key_to_public_hex(api_private_key_2)
        client.api_keys.register_api_key(api_public_key_2)
        client.api_keys.get_api_keys()
        client.api_keys.delete_api_key(api_public_key_2)
Exemple #4
0
    def test_onboard_with_private_keys(self):
        # Generate keys.
        api_private_key = generate_private_key_hex_unsafe()
        stark_private_key = generate_private_key_hex_unsafe()
        eth_private_key = Web3(None).eth.account.create().key

        # Create client WITH private keys.
        client = Client(
            host=API_HOST,
            api_private_key=api_private_key,
            stark_private_key=stark_private_key,
            eth_private_key=eth_private_key,
        )

        # Onboard the user.
        client.onboarding.create_user()

        # Register and then revoke a second API key.
        api_private_key_2 = generate_private_key_hex_unsafe()
        api_public_key_2 = private_key_to_public_hex(api_private_key_2)
        client.api_keys.register_api_key(api_public_key_2)
        client.api_keys.get_api_keys()
        client.api_keys.delete_api_key(api_public_key_2)
Exemple #5
0
    def test_integration(self):
        # Create an Ethereum account.
        web3 = Web3(None)
        web3_account = web3.eth.account.create()
        ethereum_address = web3_account.address

        # Generate STARK keys.
        api_private_key = generate_private_key_hex_unsafe()
        stark_private_key = generate_private_key_hex_unsafe()

        # Create client.
        client = Client(
            host=os.environ.get('V3_API_HOST', DEFAULT_HOST),
            api_private_key=api_private_key,
            stark_private_key=stark_private_key,
            web3_account=web3_account,
        )

        # Onboard user.
        client.onboarding.create_user(ethereum_address=ethereum_address, )

        # Get the user.
        get_user_result = client.private.get_user()
        assert get_user_result == {
            'user': {
                'ethereumAddress': ethereum_address.lower(),
                'isRegistered': False,
                'email': None,
                'username': None,
                'userData': {},
                'makerFeeRate': '0.05',
                'takerFeeRate': '0.04',
                'makerVolume30D': '0',
                'takerVolume30D': '0',
                'fees30D': '0',
            },
        }

        # Get the registration signature.
        get_registration_result = client.private.get_registration()
        assert re.match(
            '0x[0-9a-f]{130}$',
            get_registration_result['signature'],
        ) is not None, (
            'Invalid registration result: {}'.format(get_registration_result))

        # Set the user's username.
        username = '******'.format(int(time.time()))
        client.private.update_user(username=username)

        # Create a second account under the same user.
        #
        # NOTE: Support for multiple accounts under the same user is limited.
        # The frontend does not currently support mutiple accounts per user.
        stark_private_key_2 = generate_private_key_hex_unsafe()
        stark_public_key_2 = private_key_to_public_hex(stark_private_key_2)
        client.private.create_account(stark_public_key=stark_public_key_2, )

        # Get the primary account.
        get_account_result = client.private.get_account(
            ethereum_address=ethereum_address, )
        account = get_account_result['account']
        assert account['starkKey'] == client.stark_public_key

        # Get all accounts.
        get_all_accounts_result = client.private.get_accounts()
        get_all_accounts_public_keys = [
            a['starkKey'] for a in get_all_accounts_result['accounts']
        ]
        assert client.stark_public_key in get_all_accounts_public_keys
        assert stark_public_key_2 in get_all_accounts_public_keys

        # Get postiions.
        get_positions_result = client.private.get_positions(market='BTC-USD')
        assert get_positions_result == {'positions': []}

        # Create a test deposit.
        client.private.create_test_deposit(
            from_address=ethereum_address,
            credit_amount='200',
        )

        # Post an order.
        one_minute_from_now_iso = epoch_seconds_to_iso(time.time() + 60)
        create_order_result = client.private.create_order(
            position_id=account['positionId'],
            market=constants.MARKET_BTC_USD,
            side=constants.ORDER_SIDE_BUY,
            order_type=constants.ORDER_TYPE_LIMIT,
            post_only=False,
            size='10',
            price='1000',
            limit_fee='0.1',
            expiration=one_minute_from_now_iso,
        )

        # Get the order.
        order_id = create_order_result['order']['id']
        get_order_result = client.private.get_order_by_id(order_id)
        assert get_order_result['order']['market'] == constants.MARKET_BTC_USD

        # Cancel the order.
        client.private.cancel_order(order_id)

        # Cancel all orders.
        client.private.cancel_all_orders()

        # Get open orders.
        get_orders_result = client.private.get_orders(
            market=constants.MARKET_BTC_USD,
            status=constants.POSITION_STATUS_OPEN,
        )
        assert get_orders_result == {'orders': []}

        # Get fills.
        client.private.get_fills(market=constants.MARKET_BTC_USD, )

        # Initiate a regular (slow) withdrawal.
        one_minute_from_now_iso = epoch_seconds_to_iso(time.time() + 60)
        client.private.create_withdrawal(
            position_id=account['positionId'],
            amount='1',
            asset=constants.ASSET_USDC,
            to_address=ethereum_address,
            expiration=one_minute_from_now_iso,
        )

        # Get deposits.
        deposits_result = client.private.get_transfers(
            transfer_type=constants.ACCOUNT_ACTION_DEPOSIT, )
        assert len(deposits_result['transfers']) == 1

        # Get withdrawals.
        withdrawals_result = client.private.get_transfers(
            transfer_type=constants.ACCOUNT_ACTION_WITHDRAWAL, )
        assert len(withdrawals_result['transfers']) == 1

        # Get funding payments.
        client.private.get_funding_payments(market=constants.MARKET_BTC_USD, )

        # Register a new API key.
        api_private_key_2 = generate_private_key_hex_unsafe()
        api_public_key_2 = private_key_to_public_hex(api_private_key_2)
        client.api_keys.register_api_key(
            ethereum_address=ethereum_address,
            api_public_key=api_public_key_2,
        )

        # Get all API keys.
        api_keys_result = client.api_keys.get_api_keys(
            ethereum_address=ethereum_address, )
        api_keys_public_keys = [
            a['apiKey'] for a in api_keys_result['apiKeys']
        ]
        assert client.api_public_key in api_keys_public_keys
        assert api_public_key_2 in api_keys_public_keys

        # Delete an API key.
        client.api_keys.delete_api_key(
            ethereum_address=ethereum_address,
            api_public_key=api_public_key_2,
        )

        # Get all API keys after the deletion.
        api_keys_result_after = client.api_keys.get_api_keys(
            ethereum_address=ethereum_address, )
        assert len(api_keys_result_after['apiKeys']) == 1