openethereum/js/packages/shared/redux/providers/registry/middleware.js

165 lines
4.4 KiB
JavaScript
Raw Normal View History

// Copyright 2015-2017 Parity Technologies (UK) Ltd.
2017-01-05 16:56:33 +01:00
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import { debounce } from 'lodash';
2017-05-10 14:42:26 +02:00
import lsstore from 'store';
2017-01-05 16:56:33 +01:00
import Contracts from '../../../contracts';
import registryABI from '../../../contracts/abi/registry.json';
import subscribeToEvents from '../../../util/subscribe-to-events';
2017-01-05 16:56:33 +01:00
import { setReverse, startCachingReverses } from './actions';
const STORE_KEY = '_parity::reverses';
2017-05-10 14:42:26 +02:00
export default class RegistryMiddleware {
contract;
interval;
store;
subscription;
timeout;
2017-05-10 14:42:26 +02:00
addressesToCheck = {};
2017-05-10 14:42:26 +02:00
constructor (api) {
this._api = api;
}
2017-05-10 14:42:26 +02:00
toMiddleware () {
return (store) => {
this.store = store;
return (next) => (action) => {
switch (action.type) {
case 'initAll':
next(action);
store.dispatch(startCachingReverses());
break;
case 'startCachingReverses':
this.cacheReverses();
break;
case 'stopCachingReverses':
if (this.subscription) {
this.subscription.unsubscribe();
}
if (this.interval) {
clearInterval(this.interval);
}
if (this.timeout) {
clearTimeout(this.timeout);
}
this.write.flush();
break;
case 'setReverse':
this.write(
() => store.getState().nodeStatus.netChain,
() => store.getState().registry.reverse,
() => +store.getState().nodeStatus.blockNumber
);
next(action);
break;
default:
next(action);
}
};
};
}
2017-05-10 14:42:26 +02:00
cacheReverses () {
const { registry } = Contracts.get(this._api);
2017-05-10 14:42:26 +02:00
const cached = this.read(this.store.getState().nodeStatus.netChain);
2017-05-10 14:42:26 +02:00
if (cached) {
Object
.entries(cached.reverses)
.forEach(([ address, reverse ]) => this.store.dispatch(setReverse(address, reverse)));
}
2017-05-10 14:42:26 +02:00
registry.getInstance()
.then((instance) => this._api.newContract(registryABI, instance.address))
.then((_contract) => {
this.contract = _contract;
this.subscription = subscribeToEvents(this.contract, [
'ReverseConfirmed', 'ReverseRemoved'
], {
from: cached ? cached.lastBlock : 0
});
this.subscription.on('log', this.onLog);
this.timeout = setTimeout(this.checkReverses, 10000);
this.interval = setInterval(this.checkReverses, 20000);
})
.catch((err) => {
console.error('Failed to start caching reverses:', err);
throw err;
});
}
checkReverses = () => {
Object
2017-05-10 14:42:26 +02:00
.keys(this.addressesToCheck)
.forEach((address) => {
2017-05-10 14:42:26 +02:00
this.contract
.instance
.reverse
.call({}, [ address ])
.then((reverse) => {
2017-05-10 14:42:26 +02:00
this.store.dispatch(setReverse(address, reverse));
});
});
2017-05-10 14:42:26 +02:00
this.addressesToCheck = {};
};
2017-05-10 14:42:26 +02:00
onLog = (log) => {
switch (log.event) {
case 'ReverseConfirmed':
this.addressesToCheck[log.params.reverse.value] = true;
2017-01-05 16:56:33 +01:00
break;
2017-05-10 14:42:26 +02:00
case 'ReverseRemoved':
delete this.addressesToCheck[log.params.reverse.value];
2017-04-21 15:20:43 +02:00
break;
2017-05-10 14:42:26 +02:00
}
};
2017-05-10 14:42:26 +02:00
read = (chain) => {
const reverses = lsstore.get(`${STORE_KEY}::${chain}::data`);
const lastBlock = lsstore.get(`${STORE_KEY}::${chain}::lastBlock`);
2017-05-10 14:42:26 +02:00
if (!reverses || !lastBlock) {
return null;
}
2017-05-10 14:42:26 +02:00
return { reverses, lastBlock };
};
2017-05-10 14:42:26 +02:00
write = debounce((getChain, getReverses, getLastBlock) => {
const chain = getChain();
const reverses = getReverses();
const lastBlock = getLastBlock();
lsstore.set(`${STORE_KEY}::${chain}::data`, reverses);
lsstore.set(`${STORE_KEY}::${chain}::lastBlock`, lastBlock);
}, 20000);
}