125 lines
4.2 KiB
Python
125 lines
4.2 KiB
Python
"""Test 0x Exchnage wrapper."""
|
|
|
|
import random
|
|
|
|
import pytest
|
|
from eth_utils import remove_0x_prefix
|
|
|
|
from zero_ex.contract_wrappers import Exchange, TxParams
|
|
from zero_ex.json_schemas import assert_valid
|
|
from zero_ex.order_utils import generate_order_hash_hex, Order, sign_hash
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def exchange_wrapper(ganache_provider):
|
|
"""Get an Exchange wrapper instance."""
|
|
return Exchange(provider=ganache_provider)
|
|
|
|
|
|
def create_test_order(
|
|
maker_address,
|
|
maker_asset_amount,
|
|
maker_asset_data,
|
|
taker_asset_amount,
|
|
taker_asset_data,
|
|
):
|
|
"""Create a test order."""
|
|
order: Order = {
|
|
"makerAddress": maker_address.lower(),
|
|
"takerAddress": "0x0000000000000000000000000000000000000000",
|
|
"feeRecipientAddress": "0x0000000000000000000000000000000000000000",
|
|
"senderAddress": "0x0000000000000000000000000000000000000000",
|
|
"makerAssetAmount": maker_asset_amount,
|
|
"takerAssetAmount": taker_asset_amount,
|
|
"makerFee": 0,
|
|
"takerFee": 0,
|
|
"expirationTimeSeconds": 100000000000000,
|
|
"salt": random.randint(1, 1000000000),
|
|
"makerAssetData": maker_asset_data,
|
|
"takerAssetData": taker_asset_data,
|
|
}
|
|
return order
|
|
|
|
|
|
def assert_fill_log(fill_log, maker, taker, order, order_hash):
|
|
"""assert that the fill log matches the order details"""
|
|
assert fill_log.makerAddress == maker
|
|
assert fill_log.takerAddress == taker
|
|
assert fill_log.feeRecipientAddress == order["feeRecipientAddress"]
|
|
assert fill_log.senderAddress == taker
|
|
assert fill_log.orderHash == bytes.fromhex(remove_0x_prefix(order_hash))
|
|
assert fill_log.makerAssetFilledAmount == order["makerAssetAmount"]
|
|
assert fill_log.takerAssetFilledAmount == order["takerAssetAmount"]
|
|
assert fill_log.makerFeePaid == order["makerFee"]
|
|
assert fill_log.takerFeePaid == order["takerFee"]
|
|
assert fill_log.makerAssetData == order["makerAssetData"]
|
|
assert fill_log.takerAssetData == order["takerAssetData"]
|
|
|
|
|
|
def test_exchange_wrapper__fill_order(
|
|
accounts,
|
|
exchange_wrapper, # pylint: disable=redefined-outer-name
|
|
ganache_provider,
|
|
weth_asset_data,
|
|
):
|
|
"""Test filling an order."""
|
|
taker = accounts[0]
|
|
maker = accounts[1]
|
|
exchange_address = exchange_wrapper.address
|
|
order = create_test_order(maker, 1, weth_asset_data, 1, weth_asset_data)
|
|
order_hash = generate_order_hash_hex(
|
|
order=order, exchange_address=exchange_address
|
|
)
|
|
order_signature = sign_hash(ganache_provider, maker, order_hash)
|
|
|
|
tx_hash = exchange_wrapper.fill_order(
|
|
order=order,
|
|
taker_amount=order["takerAssetAmount"],
|
|
signature=order_signature,
|
|
tx_params=TxParams(from_=taker),
|
|
)
|
|
assert_valid(tx_hash.hex(), "/hexSchema")
|
|
|
|
fill_event = exchange_wrapper.get_fill_event(tx_hash)
|
|
assert_fill_log(fill_event[0].args, maker, taker, order, order_hash)
|
|
|
|
|
|
# pylint: disable=too-many-locals
|
|
def test_exchange_wrapper__batch_fill_orders(
|
|
accounts,
|
|
exchange_wrapper, # pylint: disable=redefined-outer-name
|
|
ganache_provider,
|
|
weth_asset_data,
|
|
):
|
|
"""Test filling a batch of orders."""
|
|
taker = accounts[0]
|
|
maker = accounts[1]
|
|
exchange_address = exchange_wrapper.address
|
|
orders = []
|
|
order_1 = create_test_order(maker, 1, weth_asset_data, 1, weth_asset_data)
|
|
order_2 = create_test_order(maker, 1, weth_asset_data, 1, weth_asset_data)
|
|
orders.append(order_1)
|
|
orders.append(order_2)
|
|
order_hashes = [
|
|
generate_order_hash_hex(order=order, exchange_address=exchange_address)
|
|
for order in orders
|
|
]
|
|
order_signatures = [
|
|
sign_hash(ganache_provider, maker, order_hash)
|
|
for order_hash in order_hashes
|
|
]
|
|
taker_amounts = [order["takerAssetAmount"] for order in orders]
|
|
tx_hash = exchange_wrapper.batch_fill_orders(
|
|
orders=orders,
|
|
taker_amounts=taker_amounts,
|
|
signatures=order_signatures,
|
|
tx_params=TxParams(from_=taker),
|
|
)
|
|
assert_valid(tx_hash.hex(), "/hexSchema")
|
|
|
|
fill_events = exchange_wrapper.get_fill_event(tx_hash)
|
|
for index, order in enumerate(orders):
|
|
assert_fill_log(
|
|
fill_events[index].args, maker, taker, order, order_hashes[index]
|
|
)
|