1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
import * as _ from 'lodash';
import {schemas} from '0x-json-schemas';
import {ZeroEx} from '../';
import {EventWatcher} from './event_watcher';
import {assert} from '../utils/assert';
import {artifacts} from '../artifacts';
import {AbiDecoder} from '../utils/abi_decoder';
import {orderWatcherConfigSchema} from '../schemas/order_watcher_config_schema';
import {
LogEvent,
SignedOrder,
Web3Provider,
LogWithDecodedArgs,
OrderWatcherConfig,
OnOrderStateChangeCallback,
} from '../types';
import {Web3Wrapper} from '../web3_wrapper';
export class OrderStateWatcher {
private _orders = new Map<string, SignedOrder>();
private _web3Wrapper: Web3Wrapper;
private _config: OrderWatcherConfig;
private _callback?: OnOrderStateChangeCallback;
private _eventWatcher?: EventWatcher;
private _abiDecoder: AbiDecoder;
constructor(provider: Web3Provider, config?: OrderWatcherConfig) {
assert.isWeb3Provider('provider', provider);
if (!_.isUndefined(config)) {
assert.doesConformToSchema('config', config, orderWatcherConfigSchema);
}
this._web3Wrapper = new Web3Wrapper(provider);
this._config = config || {};
const artifactJSONs = _.values(artifacts);
const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
this._abiDecoder = new AbiDecoder(abiArrays);
}
public addOrder(signedOrder: SignedOrder): void {
assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
const orderHash = ZeroEx.getOrderHashHex(signedOrder);
this._orders.set(orderHash, signedOrder);
}
public removeOrder(signedOrder: SignedOrder): void {
assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
const orderHash = ZeroEx.getOrderHashHex(signedOrder);
this._orders.delete(orderHash);
}
public subscribe(callback: OnOrderStateChangeCallback): void {
assert.isFunction('callback', callback);
this._callback = callback;
this._eventWatcher = new EventWatcher(
this._web3Wrapper, this._config.mempoolPollingIntervalMs,
);
this._eventWatcher.subscribe(this._onMempoolEventCallbackAsync.bind(this));
}
public unsubscribe(): void {
delete this._callback;
if (!_.isUndefined(this._eventWatcher)) {
this._eventWatcher.unsubscribe();
}
}
private async _onMempoolEventCallbackAsync(log: LogEvent): Promise<void> {
const maybeDecodedLog = this._abiDecoder.tryToDecodeLogOrNoop(log);
if (!_.isUndefined((maybeDecodedLog as LogWithDecodedArgs<any>).event)) {
await this._revalidateOrdersAsync();
}
}
private async _revalidateOrdersAsync(): Promise<void> {
_.noop();
}
}
|
