From bda3547747c32e75c43a4fd16566dbce70a9e5c0 Mon Sep 17 00:00:00 2001 From: fabioberger Date: Sat, 14 Sep 2019 12:47:10 +0200 Subject: [PATCH] Move OrderValidator into it's own module --- cmd/mesh/rpc_handler.go | 3 +- core/core.go | 33 ++++--- core/message_handler.go | 5 +- core/validation.go | 49 ++++----- expirationwatch/expiration_watcher.go | 4 +- rpc/client.go | 5 +- rpc/client_server_test.go | 11 ++- rpc/service.go | 6 +- scenario/scenario.go | 2 +- zeroex/{ => ordervalidate}/order_validator.go | 99 ++++++++++--------- .../order_validator_test.go | 59 +++++------ zeroex/orderwatch/order_watcher.go | 17 ++-- 12 files changed, 151 insertions(+), 142 deletions(-) rename zeroex/{ => ordervalidate}/order_validator.go (91%) rename zeroex/{ => ordervalidate}/order_validator_test.go (90%) diff --git a/cmd/mesh/rpc_handler.go b/cmd/mesh/rpc_handler.go index ee629538a..183971d3c 100644 --- a/cmd/mesh/rpc_handler.go +++ b/cmd/mesh/rpc_handler.go @@ -14,6 +14,7 @@ import ( "github.com/0xProject/0x-mesh/core" "github.com/0xProject/0x-mesh/rpc" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" ethRpc "github.com/ethereum/go-ethereum/rpc" peerstore "github.com/libp2p/go-libp2p-peerstore" log "github.com/sirupsen/logrus" @@ -70,7 +71,7 @@ func (handler *rpcHandler) GetOrders(page, perPage int, snapshotID string) (*rpc } // AddOrders is called when an RPC client calls AddOrders. -func (handler *rpcHandler) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) { +func (handler *rpcHandler) AddOrders(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) { log.WithField("count", len(signedOrdersRaw)).Debug("received AddOrders request via RPC") validationResults, err := handler.app.AddOrders(signedOrdersRaw) if err != nil { diff --git a/core/core.go b/core/core.go index f30e10d73..f4d476fb5 100644 --- a/core/core.go +++ b/core/core.go @@ -23,6 +23,7 @@ import ( "github.com/0xProject/0x-mesh/p2p" "github.com/0xProject/0x-mesh/rpc" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/0xProject/0x-mesh/zeroex/orderwatch" "github.com/albrow/stringset" "github.com/ethereum/go-ethereum/common" @@ -111,7 +112,7 @@ type App struct { blockWatcher *blockwatch.Watcher orderWatcher *orderwatch.Watcher ethWatcher *ethereum.ETHWatcher - orderValidator *zeroex.OrderValidator + orderValidator *ordervalidate.OrderValidator orderJSONSchema *gojsonschema.Schema meshMessageJSONSchema *gojsonschema.Schema snapshotExpirationWatcher *expirationwatch.Watcher @@ -138,8 +139,8 @@ func New(config Config) (*App, error) { } log.AddHook(loghooks.NewPeerIDHook(peerID)) - if config.EthereumRPCMaxContentLength < zeroex.MaxOrderSizeInBytes { - return nil, fmt.Errorf("Cannot set `EthereumRPCMaxContentLength` to be less then MaxOrderSizeInBytes: %d", zeroex.MaxOrderSizeInBytes) + if config.EthereumRPCMaxContentLength < ordervalidate.MaxOrderSizeInBytes { + return nil, fmt.Errorf("Cannot set `EthereumRPCMaxContentLength` to be less then MaxOrderSizeInBytes: %d", ordervalidate.MaxOrderSizeInBytes) } config = unquoteConfig(config) @@ -179,7 +180,7 @@ func New(config Config) (*App, error) { blockWatcher := blockwatch.New(blockWatcherConfig) // Initialize the order validator - orderValidator, err := zeroex.NewOrderValidator(ethClient, config.EthereumNetworkID, config.EthereumRPCMaxContentLength, config.OrderExpirationBuffer) + orderValidator, err := ordervalidate.NewOrderValidator(ethClient, config.EthereumNetworkID, config.EthereumRPCMaxContentLength, config.OrderExpirationBuffer) if err != nil { return nil, err } @@ -555,10 +556,10 @@ func (app *App) GetOrders(page, perPage int, snapshotID string) (*rpc.GetOrdersR // AddOrders can be used to add orders to Mesh. It validates the given orders // and if they are valid, will store and eventually broadcast the orders to peers. -func (app *App) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) { - allValidationResults := &zeroex.ValidationResults{ - Accepted: []*zeroex.AcceptedOrderInfo{}, - Rejected: []*zeroex.RejectedOrderInfo{}, +func (app *App) AddOrders(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) { + allValidationResults := &ordervalidate.ValidationResults{ + Accepted: []*ordervalidate.AcceptedOrderInfo{}, + Rejected: []*ordervalidate.RejectedOrderInfo{}, } orderHashesSeen := map[common.Hash]struct{}{} schemaValidOrders := []*zeroex.SignedOrder{} @@ -571,11 +572,11 @@ func (app *App) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.Validatio signedOrder = nil } log.WithField("signedOrderRaw", string(signedOrderBytes)).Info("Unexpected error while attempting to validate signedOrderJSON against schema") - allValidationResults.Rejected = append(allValidationResults.Rejected, &zeroex.RejectedOrderInfo{ + allValidationResults.Rejected = append(allValidationResults.Rejected, &ordervalidate.RejectedOrderInfo{ SignedOrder: signedOrder, - Kind: zeroex.MeshValidation, - Status: zeroex.RejectedOrderStatus{ - Code: zeroex.ROInvalidSchemaCode, + Kind: ordervalidate.MeshValidation, + Status: ordervalidate.RejectedOrderStatus{ + Code: ordervalidate.ROInvalidSchemaCode, Message: "order did not pass JSON-schema validation: Malformed JSON or empty payload", }, }) @@ -583,17 +584,17 @@ func (app *App) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.Validatio } if !result.Valid() { log.WithField("signedOrderRaw", string(signedOrderBytes)).Info("Order failed schema validation") - status := zeroex.RejectedOrderStatus{ - Code: zeroex.ROInvalidSchemaCode, + status := ordervalidate.RejectedOrderStatus{ + Code: ordervalidate.ROInvalidSchemaCode, Message: fmt.Sprintf("order did not pass JSON-schema validation: %s", result.Errors()), } signedOrder := &zeroex.SignedOrder{} if err := signedOrder.UnmarshalJSON(signedOrderBytes); err != nil { signedOrder = nil } - allValidationResults.Rejected = append(allValidationResults.Rejected, &zeroex.RejectedOrderInfo{ + allValidationResults.Rejected = append(allValidationResults.Rejected, &ordervalidate.RejectedOrderInfo{ SignedOrder: signedOrder, - Kind: zeroex.MeshValidation, + Kind: ordervalidate.MeshValidation, Status: status, }) continue diff --git a/core/message_handler.go b/core/message_handler.go index b740bb996..37c83c6f2 100644 --- a/core/message_handler.go +++ b/core/message_handler.go @@ -6,6 +6,7 @@ import ( "github.com/0xProject/0x-mesh/meshdb" "github.com/0xProject/0x-mesh/p2p" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/ethereum/go-ethereum/common" log "github.com/sirupsen/logrus" ) @@ -76,7 +77,7 @@ func (app *App) HandleMessages(messages []*p2p.Message) error { log.WithFields(map[string]interface{}{ "error": err, "from": msg.From, - "maxOrderSizeInBytes": zeroex.MaxOrderSizeInBytes, + "maxOrderSizeInBytes": ordervalidate.MaxOrderSizeInBytes, "actualSizeInBytes": len(msg.Data), }).Trace("received message that exceeds maximum size") app.handlePeerScoreEvent(msg.From, psInvalidMessage) @@ -168,7 +169,7 @@ func (app *App) HandleMessages(messages []*p2p.Message) error { "from": msg.From.String(), }).Trace("not storing rejected order received from peer") switch rejectedOrderInfo.Status { - case zeroex.ROInternalError, zeroex.ROEthRPCRequestFailed, zeroex.ROCoordinatorRequestFailed: + case ordervalidate.ROInternalError, ordervalidate.ROEthRPCRequestFailed, ordervalidate.ROCoordinatorRequestFailed: // Don't incur a negative score for these status types (it might not be // their fault). default: diff --git a/core/validation.go b/core/validation.go index b5c8fa24a..3bc3e5d5c 100644 --- a/core/validation.go +++ b/core/validation.go @@ -9,11 +9,12 @@ import ( "github.com/0xProject/0x-mesh/meshdb" "github.com/0xProject/0x-mesh/p2p" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" log "github.com/sirupsen/logrus" "github.com/xeipuuv/gojsonschema" ) -var errMaxSize = fmt.Errorf("message exceeds maximum size of %d bytes", zeroex.MaxOrderSizeInBytes) +var errMaxSize = fmt.Errorf("message exceeds maximum size of %d bytes", ordervalidate.MaxOrderSizeInBytes) // JSON-schema schemas var ( @@ -94,8 +95,8 @@ func (app *App) schemaValidateMeshMessage(o []byte) (*gojsonschema.Result, error // validateOrders applies general 0x validation and Mesh-specific validation to // the given orders. -func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*zeroex.ValidationResults, error) { - results := &zeroex.ValidationResults{} +func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*ordervalidate.ValidationResults, error) { + results := &ordervalidate.ValidationResults{} validMeshOrders := []*zeroex.SignedOrder{} contractAddresses, err := ethereum.GetContractAddressesForNetworkID(app.networkID) if err != nil { @@ -105,11 +106,11 @@ func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*zeroex.Validation orderHash, err := order.ComputeOrderHash() if err != nil { log.WithField("error", err).Error("could not compute order hash") - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshError, - Status: zeroex.ROInternalError, + Kind: ordervalidate.MeshError, + Status: ordervalidate.ROInternalError, }) continue } @@ -120,39 +121,39 @@ func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*zeroex.Validation // validating Coordinator orders. What we're missing is a way to effeciently // remove orders that are soft-canceled via the Coordinator API). if order.SenderAddress != constants.NullAddress { - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshValidation, - Status: zeroex.ROSenderAddressNotAllowed, + Kind: ordervalidate.MeshValidation, + Status: ordervalidate.ROSenderAddressNotAllowed, }) continue } if order.ExchangeAddress != contractAddresses.Exchange { - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshValidation, - Status: zeroex.ROIncorrectNetwork, + Kind: ordervalidate.MeshValidation, + Status: ordervalidate.ROIncorrectNetwork, }) continue } if err := validateOrderSize(order); err != nil { if err == errMaxSize { - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshValidation, - Status: zeroex.ROMaxOrderSizeExceeded, + Kind: ordervalidate.MeshValidation, + Status: ordervalidate.ROMaxOrderSizeExceeded, }) continue } else { log.WithField("error", err).Error("could not validate order size") - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshError, - Status: zeroex.ROInternalError, + Kind: ordervalidate.MeshError, + Status: ordervalidate.ROInternalError, }) continue } @@ -169,16 +170,16 @@ func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*zeroex.Validation } else { // If stored but flagged for removal, reject it if dbOrder.IsRemoved { - results.Rejected = append(results.Rejected, &zeroex.RejectedOrderInfo{ + results.Rejected = append(results.Rejected, &ordervalidate.RejectedOrderInfo{ OrderHash: orderHash, SignedOrder: order, - Kind: zeroex.MeshValidation, - Status: zeroex.ROOrderAlreadyStoredAndUnfillable, + Kind: ordervalidate.MeshValidation, + Status: ordervalidate.ROOrderAlreadyStoredAndUnfillable, }) continue } else { // If stored but not flagged for removal, accept it without re-validation - results.Accepted = append(results.Accepted, &zeroex.AcceptedOrderInfo{ + results.Accepted = append(results.Accepted, &ordervalidate.AcceptedOrderInfo{ OrderHash: orderHash, SignedOrder: order, FillableTakerAssetAmount: dbOrder.FillableTakerAssetAmount, @@ -198,7 +199,7 @@ func (app *App) validateOrders(orders []*zeroex.SignedOrder) (*zeroex.Validation } func validateMessageSize(message *p2p.Message) error { - if len(message.Data) > zeroex.MaxOrderSizeInBytes { + if len(message.Data) > ordervalidate.MaxOrderSizeInBytes { return errMaxSize } return nil @@ -209,7 +210,7 @@ func validateOrderSize(order *zeroex.SignedOrder) error { if err != nil { return err } - if len(encoded) > zeroex.MaxOrderSizeInBytes { + if len(encoded) > ordervalidate.MaxOrderSizeInBytes { return errMaxSize } return nil diff --git a/expirationwatch/expiration_watcher.go b/expirationwatch/expiration_watcher.go index 5ef53100a..49129ade1 100644 --- a/expirationwatch/expiration_watcher.go +++ b/expirationwatch/expiration_watcher.go @@ -6,7 +6,7 @@ import ( "sync" "time" - "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/albrow/stringset" "github.com/ocdogan/rbt" log "github.com/sirupsen/logrus" @@ -137,7 +137,7 @@ func (w *Watcher) prune() []ExpiredItem { } expirationTimeSeconds := int64(*key.(*rbt.Int64Key)) expirationTime := time.Unix(expirationTimeSeconds, 0) - if !zeroex.IsExpired(expirationTime, w.expirationBuffer) { + if !ordervalidate.IsExpired(expirationTime, w.expirationBuffer) { break } ids := value.(stringset.Set) diff --git a/rpc/client.go b/rpc/client.go index 883a03831..c8a055416 100644 --- a/rpc/client.go +++ b/rpc/client.go @@ -4,6 +4,7 @@ import ( "context" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rpc" peer "github.com/libp2p/go-libp2p-peer" @@ -30,8 +31,8 @@ func NewClient(addr string) (*Client, error) { // AddOrders adds orders to the 0x Mesh node and broadcasts them throughout the // 0x Mesh network. -func (c *Client) AddOrders(orders []*zeroex.SignedOrder) (*zeroex.ValidationResults, error) { - var validationResults zeroex.ValidationResults +func (c *Client) AddOrders(orders []*zeroex.SignedOrder) (*ordervalidate.ValidationResults, error) { + var validationResults ordervalidate.ValidationResults if err := c.rpcClient.Call(&validationResults, "mesh_addOrders", orders); err != nil { return nil, err } diff --git a/rpc/client_server_test.go b/rpc/client_server_test.go index 7863b222a..e62d9c388 100644 --- a/rpc/client_server_test.go +++ b/rpc/client_server_test.go @@ -14,6 +14,7 @@ import ( "github.com/0xProject/0x-mesh/constants" "github.com/0xProject/0x-mesh/ethereum" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rpc" peer "github.com/libp2p/go-libp2p-peer" @@ -26,14 +27,14 @@ import ( // dummyRPCHandler is used for testing purposes. It allows declaring handlers // for some requests or all of them, depending on testing needs. type dummyRPCHandler struct { - addOrdersHandler func(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) + addOrdersHandler func(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) getOrdersHandler func(page, perPage int, snapshotID string) (*GetOrdersResponse, error) addPeerHandler func(peerInfo peerstore.PeerInfo) error getStatsHandler func() (*GetStatsResponse, error) subscribeToOrdersHandler func(ctx context.Context) (*rpc.Subscription, error) } -func (d *dummyRPCHandler) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) { +func (d *dummyRPCHandler) AddOrders(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) { if d.addOrdersHandler == nil { return nil, errors.New("dummyRPCHandler: no handler set for AddOrder") } @@ -124,16 +125,16 @@ func TestAddOrdersSuccess(t *testing.T) { wg := &sync.WaitGroup{} wg.Add(1) rpcHandler := &dummyRPCHandler{ - addOrdersHandler: func(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) { + addOrdersHandler: func(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) { require.Len(t, signedOrdersRaw, 1) - validationResponse := &zeroex.ValidationResults{} + validationResponse := &ordervalidate.ValidationResults{} for _, signedOrderRaw := range signedOrdersRaw { signedOrder := &zeroex.SignedOrder{} err := signedOrder.UnmarshalJSON([]byte(*signedOrderRaw)) require.NoError(t, err) orderHash, err := signedOrder.ComputeOrderHash() require.NoError(t, err) - validationResponse.Accepted = append(validationResponse.Accepted, &zeroex.AcceptedOrderInfo{ + validationResponse.Accepted = append(validationResponse.Accepted, &ordervalidate.AcceptedOrderInfo{ OrderHash: orderHash, SignedOrder: signedOrder, FillableTakerAssetAmount: signedOrder.TakerAssetAmount, diff --git a/rpc/service.go b/rpc/service.go index 984d95436..a705169d5 100644 --- a/rpc/service.go +++ b/rpc/service.go @@ -8,7 +8,7 @@ import ( "time" "github.com/0xProject/0x-mesh/constants" - "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/ethereum/go-ethereum/rpc" ethRpc "github.com/ethereum/go-ethereum/rpc" peer "github.com/libp2p/go-libp2p-peer" @@ -28,7 +28,7 @@ type rpcService struct { // RPCHandler is used to respond to incoming requests from the client. type RPCHandler interface { // AddOrders is called when the client sends an AddOrders request. - AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) + AddOrders(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) // GetOrders is called when the clients sends a GetOrders request GetOrders(page, perPage int, snapshotID string) (*GetOrdersResponse, error) // AddPeer is called when the client sends an AddPeer request. @@ -118,7 +118,7 @@ func SetupHeartbeat(ctx context.Context) (*ethRpc.Subscription, error) { } // AddOrders calls rpcHandler.AddOrders and returns the validation results. -func (s *rpcService) AddOrders(signedOrdersRaw []*json.RawMessage) (*zeroex.ValidationResults, error) { +func (s *rpcService) AddOrders(signedOrdersRaw []*json.RawMessage) (*ordervalidate.ValidationResults, error) { return s.rpcHandler.AddOrders(signedOrdersRaw) } diff --git a/scenario/scenario.go b/scenario/scenario.go index bbaa25622..40d7365cc 100644 --- a/scenario/scenario.go +++ b/scenario/scenario.go @@ -50,7 +50,7 @@ func SetupBalancesAndAllowances(t *testing.T, makerAddress, takerAddress common. // Transfer ZRX to makerAddress opts = &bind.TransactOpts{ From: zrxCoinbase, - Signer: GetTestSignerFn(zrxCoinbase), + Signer: getTestSignerFn(zrxCoinbase), } txn, err = zrx.Transfer(opts, makerAddress, zrxAmount) require.NoError(t, err) diff --git a/zeroex/order_validator.go b/zeroex/ordervalidate/order_validator.go similarity index 91% rename from zeroex/order_validator.go rename to zeroex/ordervalidate/order_validator.go index 792284104..95fd26c50 100644 --- a/zeroex/order_validator.go +++ b/zeroex/ordervalidate/order_validator.go @@ -1,4 +1,4 @@ -package zeroex +package ordervalidate import ( "bytes" @@ -15,6 +15,7 @@ import ( "github.com/0xProject/0x-mesh/ethereum" "github.com/0xProject/0x-mesh/ethereum/wrappers" + "github.com/0xProject/0x-mesh/zeroex" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" @@ -42,24 +43,24 @@ const concurrencyLimit = 5 // machines with a `Code` type RejectedOrderInfo struct { OrderHash common.Hash `json:"orderHash"` - SignedOrder *SignedOrder `json:"signedOrder"` + SignedOrder *zeroex.SignedOrder `json:"signedOrder"` Kind RejectedOrderKind `json:"kind"` Status RejectedOrderStatus `json:"status"` } // AcceptedOrderInfo represents an fillable order and how much it could be filled for type AcceptedOrderInfo struct { - OrderHash common.Hash `json:"orderHash"` - SignedOrder *SignedOrder `json:"signedOrder"` - FillableTakerAssetAmount *big.Int `json:"fillableTakerAssetAmount"` - IsNew bool `json:"isNew"` + OrderHash common.Hash `json:"orderHash"` + SignedOrder *zeroex.SignedOrder `json:"signedOrder"` + FillableTakerAssetAmount *big.Int `json:"fillableTakerAssetAmount"` + IsNew bool `json:"isNew"` } type acceptedOrderInfoJSON struct { - OrderHash string `json:"orderHash"` - SignedOrder *SignedOrder `json:"signedOrder"` - FillableTakerAssetAmount string `json:"fillableTakerAssetAmount"` - IsNew bool `json:"isNew"` + OrderHash string `json:"orderHash"` + SignedOrder *zeroex.SignedOrder `json:"signedOrder"` + FillableTakerAssetAmount string `json:"fillableTakerAssetAmount"` + IsNew bool `json:"isNew"` } // MarshalJSON is a custom Marshaler for AcceptedOrderInfo @@ -185,19 +186,19 @@ var ( const ROInvalidSchemaCode = "InvalidSchema" // ConvertRejectOrderCodeToOrderEventKind converts an RejectOrderCode to an OrderEventKind type -func ConvertRejectOrderCodeToOrderEventKind(rejectedOrderStatus RejectedOrderStatus) (OrderEventKind, bool) { +func ConvertRejectOrderCodeToOrderEventKind(rejectedOrderStatus RejectedOrderStatus) (zeroex.OrderEventKind, bool) { switch rejectedOrderStatus { case ROExpired: - return EKOrderExpired, true + return zeroex.EKOrderExpired, true case ROFullyFilled: - return EKOrderFullyFilled, true + return zeroex.EKOrderFullyFilled, true case ROCancelled: - return EKOrderCancelled, true + return zeroex.EKOrderCancelled, true case ROUnfunded: - return EKOrderBecameUnfunded, true + return zeroex.EKOrderBecameUnfunded, true default: // Catch-all returns Invalid OrderEventKind - return EKInvalid, false + return zeroex.EKInvalid, false } } @@ -228,7 +229,7 @@ type OrderValidator struct { devUtilsABI abi.ABI devUtils *wrappers.DevUtils coordinatorRegistry *wrappers.CoordinatorRegistry - assetDataDecoder *AssetDataDecoder + assetDataDecoder *zeroex.AssetDataDecoder networkID int cachedFeeRecipientToEndpoint map[common.Address]string contractAddresses ethereum.ContractAddresses @@ -253,7 +254,7 @@ func NewOrderValidator(ethClient *ethclient.Client, networkID int, maxRequestCon if err != nil { return nil, err } - assetDataDecoder := NewAssetDataDecoder() + assetDataDecoder := zeroex.NewAssetDataDecoder() return &OrderValidator{ maxRequestContentLength: maxRequestContentLength, @@ -272,7 +273,7 @@ func NewOrderValidator(ethClient *ethclient.Client, networkID int, maxRequestCon // requests concurrently. If a request fails, re-attempt it up to four times before giving up. // If it some requests fail, this method still returns whatever order information it was able to // retrieve. -func (o *OrderValidator) BatchValidate(rawSignedOrders []*SignedOrder, areNewOrders bool) *ValidationResults { +func (o *OrderValidator) BatchValidate(rawSignedOrders []*zeroex.SignedOrder, areNewOrders bool) *ValidationResults { if len(rawSignedOrders) == 0 { return &ValidationResults{} } @@ -288,7 +289,7 @@ func (o *OrderValidator) BatchValidate(rawSignedOrders []*SignedOrder, areNewOrd validationResults.Rejected = append(validationResults.Rejected, rejectedOrderInfo) } - signedOrderChunks := [][]*SignedOrder{} + signedOrderChunks := [][]*zeroex.SignedOrder{} chunkSizes := o.computeOptimalChunkSizes(signedOrders) for _, chunkSize := range chunkSizes { signedOrderChunks = append(signedOrderChunks, signedOrders[:chunkSize]) @@ -301,7 +302,7 @@ func (o *OrderValidator) BatchValidate(rawSignedOrders []*SignedOrder, areNewOrd wg := &sync.WaitGroup{} for i, signedOrders := range signedOrderChunks { wg.Add(1) - go func(signedOrders []*SignedOrder, i int) { + go func(signedOrders []*zeroex.SignedOrder, i int) { orders := []wrappers.OrderWithoutExchangeAddress{} for _, signedOrder := range signedOrders { orders = append(orders, signedOrder.ConvertToOrderWithoutExchangeAddress()) @@ -373,21 +374,21 @@ func (o *OrderValidator) BatchValidate(rawSignedOrders []*SignedOrder, areNewOrd fillableTakerAssetAmount := results.FillableTakerAssetAmounts[j] orderHash := common.Hash(orderInfo.OrderHash) signedOrder := signedOrders[j] - orderStatus := OrderStatus(orderInfo.OrderStatus) + orderStatus := zeroex.OrderStatus(orderInfo.OrderStatus) if !isValidSignature { - orderStatus = OSSignatureInvalid + orderStatus = zeroex.OSSignatureInvalid } switch orderStatus { - case OSExpired, OSFullyFilled, OSCancelled, OSSignatureInvalid: + case zeroex.OSExpired, zeroex.OSFullyFilled, zeroex.OSCancelled, zeroex.OSSignatureInvalid: var status RejectedOrderStatus switch orderStatus { - case OSExpired: + case zeroex.OSExpired: status = ROExpired - case OSFullyFilled: + case zeroex.OSFullyFilled: status = ROFullyFilled - case OSCancelled: + case zeroex.OSCancelled: status = ROCancelled - case OSSignatureInvalid: + case zeroex.OSSignatureInvalid: status = ROInvalidSignature } validationResults.Rejected = append(validationResults.Rejected, &RejectedOrderInfo{ @@ -397,7 +398,7 @@ func (o *OrderValidator) BatchValidate(rawSignedOrders []*SignedOrder, areNewOrd Status: status, }) continue - case OSFillable: + case zeroex.OSFillable: remainingTakerAssetAmount := big.NewInt(0).Sub(signedOrder.TakerAssetAmount, orderInfo.OrderTakerAssetFilledAmount) // If `fillableTakerAssetAmount` != `remainingTakerAssetAmount`, the order is partially fillable. We consider // partially fillable orders as invalid @@ -438,11 +439,11 @@ type softCancelResponse struct { // that it hasn't been cancelled off-chain (soft cancellation). It does this by looking up the Coordinator server endpoint // given the `feeRecipientAddress` specified in the order, and then hitting that endpoint to query whether the orders have // been soft cancelled. -func (o *OrderValidator) batchValidateSoftCancelled(signedOrders []*SignedOrder) ([]*SignedOrder, []*RejectedOrderInfo) { +func (o *OrderValidator) batchValidateSoftCancelled(signedOrders []*zeroex.SignedOrder) ([]*zeroex.SignedOrder, []*RejectedOrderInfo) { rejectedOrderInfos := []*RejectedOrderInfo{} - validSignedOrders := []*SignedOrder{} + validSignedOrders := []*zeroex.SignedOrder{} - endpointToSignedOrders := map[string][]*SignedOrder{} + endpointToSignedOrders := map[string][]*zeroex.SignedOrder{} for _, signedOrder := range signedOrders { if signedOrder.SenderAddress != o.contractAddresses.Coordinator { validSignedOrders = append(validSignedOrders, signedOrder) @@ -490,14 +491,14 @@ func (o *OrderValidator) batchValidateSoftCancelled(signedOrders []*SignedOrder) } existingOrders, ok := endpointToSignedOrders[endpoint] if !ok { - endpointToSignedOrders[endpoint] = []*SignedOrder{signedOrder} + endpointToSignedOrders[endpoint] = []*zeroex.SignedOrder{signedOrder} } else { endpointToSignedOrders[endpoint] = append(existingOrders, signedOrder) } } for endpoint, signedOrders := range endpointToSignedOrders { - orderHashToSignedOrder := map[common.Hash]*SignedOrder{} + orderHashToSignedOrder := map[common.Hash]*zeroex.SignedOrder{} orderHashes := []common.Hash{} for _, signedOrder := range signedOrders { orderHash, err := signedOrder.ComputeOrderHash() @@ -614,9 +615,9 @@ func (o *OrderValidator) batchValidateSoftCancelled(signedOrders []*SignedOrder) // - `Signature` contains a properly encoded 0x signature // - Validate that order isn't expired // Returns an orderHashToInfo mapping with all invalid orders added to it, and an array of the valid signedOrders -func (o *OrderValidator) BatchOffchainValidation(signedOrders []*SignedOrder) ([]*SignedOrder, []*RejectedOrderInfo) { +func (o *OrderValidator) BatchOffchainValidation(signedOrders []*zeroex.SignedOrder) ([]*zeroex.SignedOrder, []*RejectedOrderInfo) { rejectedOrderInfos := []*RejectedOrderInfo{} - offchainValidSignedOrders := []*SignedOrder{} + offchainValidSignedOrders := []*zeroex.SignedOrder{} for _, signedOrder := range signedOrders { orderHash, err := signedOrder.ComputeOrderHash() if err != nil { @@ -708,19 +709,19 @@ func (o *OrderValidator) isSupportedAssetData(assetData []byte) bool { } switch assetDataName { case "ERC20Token": - var decodedAssetData ERC20AssetData + var decodedAssetData zeroex.ERC20AssetData err := o.assetDataDecoder.Decode(assetData, &decodedAssetData) if err != nil { return false } case "ERC721Token": - var decodedAssetData ERC721AssetData + var decodedAssetData zeroex.ERC721AssetData err := o.assetDataDecoder.Decode(assetData, &decodedAssetData) if err != nil { return false } case "MultiAsset": - var decodedAssetData MultiAssetData + var decodedAssetData zeroex.MultiAssetData err := o.assetDataDecoder.Decode(assetData, &decodedAssetData) if err != nil { return false @@ -757,7 +758,7 @@ const emptyGetOrderRelevantStatesCallDataByteLength = 268 */ const jsonRPCPayloadByteLength = 444 -func (o *OrderValidator) computeABIEncodedSignedOrderByteLength(signedOrder *SignedOrder) (int, error) { +func (o *OrderValidator) computeABIEncodedSignedOrderByteLength(signedOrder *zeroex.SignedOrder) (int, error) { orderWithExchangeAddress := signedOrder.ConvertToOrderWithoutExchangeAddress() data, err := o.devUtilsABI.Pack( "getOrderRelevantStates", @@ -780,7 +781,7 @@ func (o *OrderValidator) computeABIEncodedSignedOrderByteLength(signedOrder *Sig // is beneath the maxRequestContentLength. It does this by implementing a greedy algorithm which ABI // encodes signedOrders one at a time until the computed payload size is as close to the // maxRequestContentLength as possible. -func (o *OrderValidator) computeOptimalChunkSizes(signedOrders []*SignedOrder) []int { +func (o *OrderValidator) computeOptimalChunkSizes(signedOrders []*zeroex.SignedOrder) []int { chunkSizes := []int{} payloadLength := jsonRPCPayloadByteLength @@ -808,33 +809,33 @@ func (o *OrderValidator) computeOptimalChunkSizes(signedOrders []*SignedOrder) [ } func isSupportedSignature(signature []byte, orderHash common.Hash) bool { - signatureType := SignatureType(signature[len(signature)-1]) + signatureType := zeroex.SignatureType(signature[len(signature)-1]) switch signatureType { - case IllegalSignature: - case InvalidSignature: + case zeroex.IllegalSignature: + case zeroex.InvalidSignature: return false - case EIP712Signature: + case zeroex.EIP712Signature: if len(signature) != 66 { return false } // TODO(fabio): Do further validation by splitting into r,s,v and do ECRecover - case EthSignSignature: + case zeroex.EthSignSignature: if len(signature) != 66 { return false } // TODO(fabio): Do further validation by splitting into r,s,v, add prefix to hash // and do ECRecover - case ValidatorSignature: + case zeroex.ValidatorSignature: if len(signature) < 21 { return false } - case WalletSignature: - case PreSignedSignature: + case zeroex.WalletSignature: + case zeroex.PreSignedSignature: return true default: diff --git a/zeroex/order_validator_test.go b/zeroex/ordervalidate/order_validator_test.go similarity index 90% rename from zeroex/order_validator_test.go rename to zeroex/ordervalidate/order_validator_test.go index 5da317df5..50755c0d7 100644 --- a/zeroex/order_validator_test.go +++ b/zeroex/ordervalidate/order_validator_test.go @@ -2,7 +2,7 @@ // We currently don't run these tests in WASM because of an issue in Go. See the header of // eth_watcher_test.go for more details. -package zeroex +package ordervalidate import ( "context" @@ -16,6 +16,7 @@ import ( "github.com/0xProject/0x-mesh/constants" "github.com/0xProject/0x-mesh/ethereum" "github.com/0xProject/0x-mesh/scenario" + "github.com/0xProject/0x-mesh/zeroex" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" @@ -37,8 +38,8 @@ var malformedAssetData = []byte("9HJhsAAAAAAAAAAAAAAAAInSSmtMyxtvqiYl") var malformedSignature = []byte("9HJhsAAAAAAAAAAAAAAAAInSSmtMyxtvqiYl") var multiAssetAssetData = common.Hex2Bytes("94cfcdd7000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000046000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000024f47261b00000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000204a7cb5fb70000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000003e90000000000000000000000000000000000000000000000000000000000002711000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000007d10000000000000000000000000000000000000000000000000000000000004e210000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c4800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") -var testSignedOrder = SignedOrder{ - Order: Order{ +var testSignedOrder = zeroex.SignedOrder{ + Order: zeroex.Order{ MakerAddress: makerAddress, TakerAddress: constants.NullAddress, SenderAddress: constants.NullAddress, @@ -56,7 +57,7 @@ var testSignedOrder = SignedOrder{ } type testCase struct { - SignedOrder SignedOrder + SignedOrder zeroex.SignedOrder IsValid bool ExpectedRejectedOrderStatus RejectedOrderStatus } @@ -136,7 +137,7 @@ func TestBatchValidateOffChainCases(t *testing.T) { ethClient, err := ethclient.Dial(constants.GanacheEndpoint) require.NoError(t, err) - signedOrders := []*SignedOrder{ + signedOrders := []*zeroex.SignedOrder{ &testCase.SignedOrder, } @@ -165,7 +166,7 @@ func TestBatchValidateSignatureInvalid(t *testing.T) { orderHash, err := signedOrder.ComputeOrderHash() require.NoError(t, err) - signedOrders := []*SignedOrder{ + signedOrders := []*zeroex.SignedOrder{ signedOrder, } @@ -194,7 +195,7 @@ func TestBatchValidateUnregisteredCoordinatorSoftCancels(t *testing.T) { orderHash, err := signedOrder.ComputeOrderHash() require.NoError(t, err) - signedOrders := []*SignedOrder{ + signedOrders := []*zeroex.SignedOrder{ signedOrder, } @@ -219,7 +220,7 @@ func TestBatchValidateCoordinatorSoftCancels(t *testing.T) { signedOrder.SenderAddress = ethereum.NetworkIDToContractAddresses[constants.TestNetworkID].Coordinator orderHash, err := signedOrder.ComputeOrderHash() require.NoError(t, err) - signedOrders := []*SignedOrder{ + signedOrders := []*zeroex.SignedOrder{ signedOrder, } @@ -263,7 +264,7 @@ func TestBatchValidateCoordinatorSoftCancels(t *testing.T) { const singleOrderPayloadSize = 1980 func TestComputeOptimalChunkSizesMaxContentLengthTooLow(t *testing.T) { - signedOrder, err := SignTestOrder(&testSignedOrder.Order) + signedOrder, err := zeroex.SignTestOrder(&testSignedOrder.Order) require.NoError(t, err) ethClient, err := ethclient.Dial(constants.GanacheEndpoint) @@ -273,14 +274,14 @@ func TestComputeOptimalChunkSizesMaxContentLengthTooLow(t *testing.T) { orderValidator, err := NewOrderValidator(ethClient, constants.TestNetworkID, maxContentLength, 0) require.NoError(t, err) - signedOrders := []*SignedOrder{signedOrder} + signedOrders := []*zeroex.SignedOrder{signedOrder} assert.Panics(t, func() { orderValidator.computeOptimalChunkSizes(signedOrders) }) } func TestComputeOptimalChunkSizes(t *testing.T) { - signedOrder, err := SignTestOrder(&testSignedOrder.Order) + signedOrder, err := zeroex.SignTestOrder(&testSignedOrder.Order) require.NoError(t, err) ethClient, err := ethclient.Dial(constants.GanacheEndpoint) @@ -290,14 +291,14 @@ func TestComputeOptimalChunkSizes(t *testing.T) { orderValidator, err := NewOrderValidator(ethClient, constants.TestNetworkID, maxContentLength, 0) require.NoError(t, err) - signedOrders := []*SignedOrder{signedOrder, signedOrder, signedOrder, signedOrder} + signedOrders := []*zeroex.SignedOrder{signedOrder, signedOrder, signedOrder, signedOrder} chunkSizes := orderValidator.computeOptimalChunkSizes(signedOrders) expectedChunkSizes := []int{3, 1} assert.Equal(t, expectedChunkSizes, chunkSizes) } -var testMultiAssetSignedOrder = SignedOrder{ - Order: Order{ +var testMultiAssetSignedOrder = zeroex.SignedOrder{ + Order: zeroex.Order{ MakerAddress: constants.GanacheAccount0, TakerAddress: constants.NullAddress, SenderAddress: constants.NullAddress, @@ -315,9 +316,9 @@ var testMultiAssetSignedOrder = SignedOrder{ } func TestComputeOptimalChunkSizesMultiAssetOrder(t *testing.T) { - signedOrder, err := SignTestOrder(&testSignedOrder.Order) + signedOrder, err := zeroex.SignTestOrder(&testSignedOrder.Order) require.NoError(t, err) - signedMultiAssetOrder, err := SignTestOrder(&testMultiAssetSignedOrder.Order) + signedMultiAssetOrder, err := zeroex.SignTestOrder(&testMultiAssetSignedOrder.Order) require.NoError(t, err) ethClient, err := ethclient.Dial(constants.GanacheEndpoint) @@ -327,7 +328,7 @@ func TestComputeOptimalChunkSizesMultiAssetOrder(t *testing.T) { orderValidator, err := NewOrderValidator(ethClient, constants.TestNetworkID, maxContentLength, 0) require.NoError(t, err) - signedOrders := []*SignedOrder{signedMultiAssetOrder, signedOrder, signedOrder, signedOrder, signedOrder} + signedOrders := []*zeroex.SignedOrder{signedMultiAssetOrder, signedOrder, signedOrder, signedOrder, signedOrder} chunkSizes := orderValidator.computeOptimalChunkSizes(signedOrders) expectedChunkSizes := []int{2, 3} // MultiAsset order is larger so can only fit two orders in first chunk assert.Equal(t, expectedChunkSizes, chunkSizes) @@ -341,46 +342,46 @@ func setupSubTest(t *testing.T) func(t *testing.T) { } } -func signedOrderWithCustomMakerAssetAmount(t *testing.T, signedOrder SignedOrder, makerAssetAmount *big.Int) SignedOrder { +func signedOrderWithCustomMakerAssetAmount(t *testing.T, signedOrder zeroex.SignedOrder, makerAssetAmount *big.Int) zeroex.SignedOrder { signedOrder.MakerAssetAmount = makerAssetAmount - signedOrderWithSignature, err := SignTestOrder(&signedOrder.Order) + signedOrderWithSignature, err := zeroex.SignTestOrder(&signedOrder.Order) require.NoError(t, err) return *signedOrderWithSignature } -func signedOrderWithCustomTakerAssetAmount(t *testing.T, signedOrder SignedOrder, takerAssetAmount *big.Int) SignedOrder { +func signedOrderWithCustomTakerAssetAmount(t *testing.T, signedOrder zeroex.SignedOrder, takerAssetAmount *big.Int) zeroex.SignedOrder { signedOrder.TakerAssetAmount = takerAssetAmount - signedOrderWithSignature, err := SignTestOrder(&signedOrder.Order) + signedOrderWithSignature, err := zeroex.SignTestOrder(&signedOrder.Order) require.NoError(t, err) return *signedOrderWithSignature } -func signedOrderWithCustomMakerAssetData(t *testing.T, signedOrder SignedOrder, makerAssetData []byte) SignedOrder { +func signedOrderWithCustomMakerAssetData(t *testing.T, signedOrder zeroex.SignedOrder, makerAssetData []byte) zeroex.SignedOrder { signedOrder.MakerAssetData = makerAssetData - signedOrderWithSignature, err := SignTestOrder(&signedOrder.Order) + signedOrderWithSignature, err := zeroex.SignTestOrder(&signedOrder.Order) require.NoError(t, err) return *signedOrderWithSignature } -func signedOrderWithCustomTakerAssetData(t *testing.T, signedOrder SignedOrder, takerAssetData []byte) SignedOrder { +func signedOrderWithCustomTakerAssetData(t *testing.T, signedOrder zeroex.SignedOrder, takerAssetData []byte) zeroex.SignedOrder { signedOrder.TakerAssetData = takerAssetData - signedOrderWithSignature, err := SignTestOrder(&signedOrder.Order) + signedOrderWithSignature, err := zeroex.SignTestOrder(&signedOrder.Order) require.NoError(t, err) return *signedOrderWithSignature } -func signedOrderWithCustomExpirationTimeSeconds(t *testing.T, signedOrder SignedOrder, expirationTimeSeconds *big.Int) SignedOrder { +func signedOrderWithCustomExpirationTimeSeconds(t *testing.T, signedOrder zeroex.SignedOrder, expirationTimeSeconds *big.Int) zeroex.SignedOrder { signedOrder.ExpirationTimeSeconds = expirationTimeSeconds - signedOrderWithSignature, err := SignTestOrder(&signedOrder.Order) + signedOrderWithSignature, err := zeroex.SignTestOrder(&signedOrder.Order) require.NoError(t, err) return *signedOrderWithSignature } -func signedOrderWithCustomSignature(t *testing.T, signedOrder SignedOrder, signature []byte) SignedOrder { +func signedOrderWithCustomSignature(t *testing.T, signedOrder zeroex.SignedOrder, signature []byte) zeroex.SignedOrder { signedOrder.Signature = signature return signedOrder } -func copyOrder(order Order) Order { +func copyOrder(order zeroex.Order) zeroex.Order { return order } diff --git a/zeroex/orderwatch/order_watcher.go b/zeroex/orderwatch/order_watcher.go index 8fec324ac..5d665138b 100644 --- a/zeroex/orderwatch/order_watcher.go +++ b/zeroex/orderwatch/order_watcher.go @@ -14,6 +14,7 @@ import ( "github.com/0xProject/0x-mesh/expirationwatch" "github.com/0xProject/0x-mesh/meshdb" "github.com/0xProject/0x-mesh/zeroex" + "github.com/0xProject/0x-mesh/zeroex/ordervalidate" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" logger "github.com/sirupsen/logrus" @@ -50,13 +51,13 @@ type Watcher struct { orderFeed event.Feed orderScope event.SubscriptionScope // Subscription scope tracking current live listeners contractAddressToSeenCount map[common.Address]uint - orderValidator *zeroex.OrderValidator + orderValidator *ordervalidate.OrderValidator wasStartedOnce bool mu sync.Mutex } // New instantiates a new order watcher -func New(meshDB *meshdb.MeshDB, blockWatcher *blockwatch.Watcher, orderValidator *zeroex.OrderValidator, networkID int, expirationBuffer time.Duration) (*Watcher, error) { +func New(meshDB *meshdb.MeshDB, blockWatcher *blockwatch.Watcher, orderValidator *ordervalidate.OrderValidator, networkID int, expirationBuffer time.Duration) (*Watcher, error) { decoder, err := NewDecoder() if err != nil { return nil, err @@ -472,7 +473,7 @@ func (w *Watcher) cleanup(ctx context.Context) error { // Add adds a 0x order to the DB and watches it for changes in fillability. It // will no-op (and return nil) if the order has already been added. -func (w *Watcher) Add(orderInfo *zeroex.AcceptedOrderInfo) error { +func (w *Watcher) Add(orderInfo *ordervalidate.AcceptedOrderInfo) error { order := &meshdb.Order{ Hash: orderInfo.OrderHash, SignedOrder: orderInfo.SignedOrder, @@ -599,7 +600,7 @@ func (w *Watcher) generateOrderEventsIfChanged(ordersColTxn *db.Transaction, has oldAmountIsMoreThenNewAmount := oldFillableAmount.Cmp(newFillableAmount) == 1 expirationTime := time.Unix(order.SignedOrder.ExpirationTimeSeconds.Int64(), 0) - isExpired := zeroex.IsExpired(expirationTime, w.expirationBuffer) + isExpired := ordervalidate.IsExpired(expirationTime, w.expirationBuffer) if !isExpired && oldFillableAmount.Cmp(big.NewInt(0)) == 0 { // A previous event caused this order to be removed from DB because it's // fillableAmount became 0, but it has now been revived (e.g., block re-org @@ -643,9 +644,9 @@ func (w *Watcher) generateOrderEventsIfChanged(ordersColTxn *db.Transaction, has } for _, rejectedOrderInfo := range validationResults.Rejected { switch rejectedOrderInfo.Kind { - case zeroex.MeshError: + case ordervalidate.MeshError: // TODO(fabio): Do we want to handle MeshErrors somehow here? - case zeroex.ZeroExValidation: + case ordervalidate.ZeroExValidation: orderWithTxHashes := hashToOrderWithTxHashes[rejectedOrderInfo.OrderHash] order := orderWithTxHashes.Order oldFillableAmount := order.FillableTakerAssetAmount @@ -656,7 +657,7 @@ func (w *Watcher) generateOrderEventsIfChanged(ordersColTxn *db.Transaction, has } else { // If oldFillableAmount > 0, it got fullyFilled, cancelled, expired or unfunded, emit event w.unwatchOrder(ordersColTxn, order, big.NewInt(0)) - kind, ok := zeroex.ConvertRejectOrderCodeToOrderEventKind(rejectedOrderInfo.Status) + kind, ok := ordervalidate.ConvertRejectOrderCodeToOrderEventKind(rejectedOrderInfo.Status) if !ok { err := fmt.Errorf("no OrderEventKind corresponding to RejectedOrderStatus: %q", rejectedOrderInfo.Status) logger.WithError(err).WithField("rejectedOrderStatus", rejectedOrderInfo.Status).Error("no OrderEventKind corresponding to RejectedOrderStatus") @@ -710,7 +711,7 @@ func (w *Watcher) updateOrderDBEntry(u updatableOrdersCol, order *meshdb.Order) } } -func (w *Watcher) rewatchOrder(u updatableOrdersCol, order *meshdb.Order, orderInfo *zeroex.AcceptedOrderInfo) { +func (w *Watcher) rewatchOrder(u updatableOrdersCol, order *meshdb.Order, orderInfo *ordervalidate.AcceptedOrderInfo) { order.IsRemoved = false order.LastUpdated = time.Now().UTC() order.FillableTakerAssetAmount = orderInfo.FillableTakerAssetAmount