@ixily/activ
Version:
Alpha Capture Trade Idea Verification. Blockchain ownership proven trade ideas and strategies.
163 lines • 6.31 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.contractsInMemoryDbView = exports.InMemoryDbMaker = void 0;
const __1 = require("../../../../");
const contracts_dbview_1 = require("./in-memory/contracts.dbview");
Object.defineProperty(exports, "contractsInMemoryDbView", { enumerable: true, get: function () { return contracts_dbview_1.contractsInMemoryDbView; } });
const VIEWS = [contracts_dbview_1.contractsInMemoryDbView];
const state = {
contractDbs: new Map(),
};
const getInMemoryState = async () => {
return {
local: state,
intern: (0, contracts_dbview_1.getContractsInMemoryState)(),
};
};
const setInMemoryState = async (_state) => {
state.contractDbs = _state.local.contractDbs;
(0, contracts_dbview_1.setContractsInMemoryState)(_state.intern);
};
const existsContractDb = async (contractUniqueKey) => {
return state.contractDbs.has(contractUniqueKey);
};
const createContractDb = async (contractUniqueKey) => {
state.contractDbs.set(contractUniqueKey, {
contractUniqueKey,
lastBlockComputed: 0,
strategiesByOldest: [],
invalidStrategiesByOldest: new Map(),
strategies: new Map(),
});
};
const getLastBlockComputed = async (contractUniqueKey) => {
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${contractUniqueKey}`);
}
return contractDb.lastBlockComputed;
};
const setLastBlockComputed = async (contractUniqueKey, blockNumber) => {
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${contractUniqueKey}`);
}
contractDb.lastBlockComputed = blockNumber;
};
const includeNewIdea = async (contractUniqueKey, newIdeaEvent) => {
const contractDb = state.contractDbs.get(contractUniqueKey);
const decomposed = (0, __1.uniqueKeySplit)(contractUniqueKey);
const strategyUniqueKey = (0, __1.uniqueKeyJoin)([
decomposed[0],
decomposed[1],
newIdeaEvent.creatorAddress,
newIdeaEvent.strategyKey,
]);
let strategyData = contractDb.strategies.get(strategyUniqueKey);
const viewsArgsToReduce = [
contractUniqueKey,
newIdeaEvent,
strategyData.strategyChain,
strategyData.strategyCache,
];
for (const view of VIEWS) {
await view.reduce(...viewsArgsToReduce);
}
};
const updateStrategyChain = async (strategyUniqueKey, strategyChain, strategyCache) => {
const decomposed = (0, __1.uniqueKeySplit)(strategyUniqueKey);
// console.log('decomposed')
// console.log(decomposed)
const contractUniqueKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${contractUniqueKey}`);
}
// add this key to index if not there
const index = contractDb.strategiesByOldest.indexOf(strategyUniqueKey);
if (index === -1) {
contractDb.strategiesByOldest.push(strategyUniqueKey);
}
// get strategy from memory if there or add if not
let strategyData = contractDb.strategies.get(strategyUniqueKey);
if (!strategyData) {
strategyData = {
strategyUniqueKey: strategyUniqueKey,
strategyChain,
strategyCache,
};
contractDb.strategies.set(strategyUniqueKey, strategyData);
}
else {
strategyData.strategyChain = strategyChain;
strategyData.strategyCache = strategyCache;
}
// console.log('strategyData')
// console.log(strategyData)
};
const getStrategyChain = async (strategyUniqueKey) => {
const decomposed = (0, __1.uniqueKeySplit)(strategyUniqueKey);
const contractUniqueKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${contractUniqueKey}`);
}
const strategyData = contractDb.strategies.get(strategyUniqueKey);
if (!strategyData) {
return undefined;
}
return strategyData.strategyChain;
};
const invalidateStrategyChain = async (strategyUniqueKey, message) => {
const decomposed = (0, __1.uniqueKeySplit)(strategyUniqueKey);
const contractUniqueKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${strategyUniqueKey}`);
}
// remove this key from index if it is there
const index = contractDb.strategiesByOldest.indexOf(strategyUniqueKey);
if (index !== -1) {
contractDb.strategiesByOldest.splice(index, 1);
}
// add this key to invalid index if not there
const invalidHas = contractDb.invalidStrategiesByOldest.has(strategyUniqueKey);
if (!invalidHas) {
contractDb.invalidStrategiesByOldest.set(strategyUniqueKey, message);
}
// remove strategy from memory if there
try {
contractDb.strategies.delete(strategyUniqueKey);
}
catch (e) { }
};
const checkInvalidStrategyChain = async (strategyUniqueKey) => {
const decomposed = (0, __1.uniqueKeySplit)(strategyUniqueKey);
const contractUniqueKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const contractDb = state.contractDbs.get(contractUniqueKey);
if (!contractDb) {
throw new Error(`Contract DB not found for address: ${strategyUniqueKey}`);
}
const invalidMessage = contractDb.invalidStrategiesByOldest.get(strategyUniqueKey);
if (invalidMessage === undefined) {
return false;
}
else {
return invalidMessage;
}
};
const InMemoryDbMaker = {
getLastBlockComputed,
setLastBlockComputed,
existsContractDb,
createContractDb,
invalidateStrategyChain,
checkInvalidStrategyChain,
updateStrategyChain,
getStrategyChain,
includeNewIdea,
getState: getInMemoryState,
setState: setInMemoryState,
};
exports.InMemoryDbMaker = InMemoryDbMaker;
//# sourceMappingURL=in-memory.dbmaker.js.map