@ixily/activ
Version:
Alpha Capture Trade Idea Verification. Blockchain ownership proven trade ideas and strategies.
690 lines • 31.6 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.setContractsInMemoryState = exports.getContractsInMemoryState = exports.contractsInMemoryDbView = void 0;
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const __1 = require("../../../../../");
const state = {
contractDbs: new Map(),
contractsByOldest: [],
};
const getContractsInMemoryState = () => {
return state;
};
exports.getContractsInMemoryState = getContractsInMemoryState;
const setContractsInMemoryState = (_state) => {
state.contractDbs = _state.contractDbs;
state.contractsByOldest = _state.contractsByOldest;
};
exports.setContractsInMemoryState = setContractsInMemoryState;
const reduce = async (contractUniqueKey, newIdeaEvent, strategyChain, strategyCache) => {
// console.log('++++++++++++++++++++++++++++++++++++++')
// console.log('++++++++++++++++++++++++++++++++++++++')
// console.log('++++++++++++++++++++++++++++++++++++++')
__1.LogModule.dev('+reducing+');
__1.LogModule.dev('contractUniqueKey');
__1.LogModule.dev(contractUniqueKey);
// log.dev('newIdeaEvent')
// log.dev(newIdeaEvent)
const decomposed = (0, __1.uniqueKeySplit)(contractUniqueKey);
const chain = decomposed[0];
const contractAddress = decomposed[1];
__1.LogModule.dev('contractAddress');
__1.LogModule.dev(contractAddress);
__1.LogModule.dev('chain');
__1.LogModule.dev(chain);
const nftId = newIdeaEvent.nftId; // unique within contract
const strategyUniqueKey = (0, __1.uniqueKeyJoin)([
chain,
contractAddress,
newIdeaEvent.creatorAddress,
newIdeaEvent.strategyKey,
]);
const ideaIndex = (0, __1.uniqueKeyJoin)([chain, contractAddress, '' + nftId]);
const myIdeaKeys = {
ideaIndex,
strategyUniqueKey,
chain,
nftId,
contractAddress,
strategyKey: newIdeaEvent.strategyKey,
stageKey: newIdeaEvent.stageKey,
ideaKey: newIdeaEvent.ideaKey,
};
let myContractDb = state.contractDbs.get(contractUniqueKey);
if (myContractDb === undefined) {
myContractDb = {
contractUniqueKey,
chain,
contractAddress,
creators: new Map(),
creatorsByOldest: [],
userAccessStrategies: new Map(),
userSubscribedToStrategies: new Map(),
userAccessIdeaNfts: new Map(),
userAccessIdeaIndexesByOldest: new Map(),
userAccessIdeaKeysByStrategy: new Map(),
publicStrategies: new Set(),
publicStrategiesByOldest: [],
publicStrategiesFilled: new Map(),
ideaIndexByOldest: [],
publicIdeaIndexByOldest: [],
ideaIndexByStrategyByOldest: new Map(),
ideaIndexToKeys: new Map(),
ideaIndexToData: new Map(),
allocationStrategyPortfolios: new Map(),
allocationRebalances: new Map(),
};
__1.LogModule.dev('setting up state.contractDbs');
__1.LogModule.dev('contractUniqueKey');
__1.LogModule.dev(contractUniqueKey);
__1.LogModule.dev('myContractDb');
__1.LogModule.dev(myContractDb);
state.contractDbs.set(contractUniqueKey, myContractDb);
state.contractsByOldest.push(contractUniqueKey);
__1.LogModule.dev('state.contractsByOldest');
__1.LogModule.dev(state.contractsByOldest);
}
myContractDb = state.contractDbs.get(contractUniqueKey);
myContractDb.publicStrategiesFilled.set(strategyUniqueKey, strategyCache.strategy);
let creator = myContractDb.creators.get(newIdeaEvent.creatorAddress);
if (!creator) {
myContractDb.creatorsByOldest.push(newIdeaEvent.creatorAddress);
myContractDb.creators.set(newIdeaEvent.creatorAddress, {
creatorWallet: newIdeaEvent.creatorAddress,
strategies: new Set(),
strategiesByOldest: [],
createdIdeasIndexesByOldest: [],
});
}
creator = myContractDb.creators.get(newIdeaEvent.creatorAddress);
if (!creator.strategies.has(strategyUniqueKey)) {
creator.strategies.add(strategyUniqueKey);
creator.strategiesByOldest.push(strategyUniqueKey);
}
creator.createdIdeasIndexesByOldest.push(ideaIndex);
const stg = myContractDb.ideaIndexByStrategyByOldest.get(strategyUniqueKey);
if (!stg) {
myContractDb.ideaIndexByStrategyByOldest.set(strategyUniqueKey, [
ideaIndex,
]);
}
else {
stg.push(ideaIndex);
}
if (!myContractDb.ideaIndexToKeys.has(ideaIndex)) {
myContractDb.ideaIndexToKeys.set(ideaIndex, myIdeaKeys);
myContractDb.ideaIndexByOldest.push(ideaIndex);
}
const idea = strategyChain.ideas.find((idea) => idea.ideaKey === newIdeaEvent.ideaKey);
const ideaStage = idea.stages.find((ideaStage) => ideaStage.ideaStageKey === newIdeaEvent.stageKey);
const openSeaIdea = ideaStage.ideaStage;
myContractDb.ideaIndexToData.set(ideaIndex, openSeaIdea);
const accessors = openSeaIdea.access?.wallets;
const addSubscriber = (subscriber) => {
if (subscriber !== newIdeaEvent.creatorAddress) {
let userSubscribedToStrategies = myContractDb.userSubscribedToStrategies.get(subscriber);
if (userSubscribedToStrategies === undefined) {
myContractDb.userSubscribedToStrategies.set(subscriber, new Set());
userSubscribedToStrategies =
myContractDb.userSubscribedToStrategies.get(subscriber);
}
userSubscribedToStrategies.add(strategyUniqueKey);
}
};
const addAccessor = (accessor) => {
let userAccessStrategies = myContractDb.userAccessStrategies.get(accessor);
if (userAccessStrategies === undefined) {
myContractDb.userAccessStrategies.set(accessor, new Set());
userAccessStrategies =
myContractDb.userAccessStrategies.get(accessor);
}
userAccessStrategies.add(strategyUniqueKey);
if (!myContractDb.userAccessIdeaNfts.has(accessor)) {
myContractDb.userAccessIdeaNfts.set(accessor, new Set());
myContractDb.userAccessIdeaIndexesByOldest.set(accessor, []);
myContractDb.userAccessIdeaKeysByStrategy.set(accessor, new Map());
}
const userAccessIdeaNfts = myContractDb.userAccessIdeaNfts.get(accessor);
if (!userAccessIdeaNfts.has(nftId)) {
userAccessIdeaNfts.add(nftId);
myContractDb.userAccessIdeaIndexesByOldest
.get(accessor)
.push(ideaIndex);
}
const userAccessIdeaKeysByStrategy = myContractDb.userAccessIdeaKeysByStrategy.get(accessor);
if (!userAccessIdeaKeysByStrategy.has(strategyUniqueKey)) {
userAccessIdeaKeysByStrategy.set(strategyUniqueKey, new Set());
}
// console.log('well done')
const stgSet = userAccessIdeaKeysByStrategy.get(strategyUniqueKey);
stgSet.add(newIdeaEvent.ideaKey);
};
addAccessor(newIdeaEvent.creatorAddress);
if (accessors !== undefined) {
// console.log('test')
for (const accessor of accessors) {
addAccessor(accessor);
addSubscriber(accessor);
}
// console.log(openSeaIdea.idea)
// console.log('openSeaIea.idea')
// console.log('fasdjfhsdujkhfjklashfljkahsdjkhlasdjkfajklshflj')
// console.log('fasdjfhsdujkhfjklashfljkahsdjkhlasdjkfajklshflj')
// console.log('fasdjfhsdujkhfjklashfljkahsdjkhlasdjkfajklshflj')
if (typeof openSeaIdea.idea !== 'string') {
if (openSeaIdea.idea.kind === 'close') {
// console.log(openSeaIdea.idea)
// console.log('openSeaIea.idea')
if (!myContractDb.publicStrategies.has(strategyUniqueKey)) {
myContractDb.publicStrategies.add(strategyUniqueKey);
myContractDb.publicStrategiesByOldest.push(strategyUniqueKey);
}
myContractDb.publicIdeaIndexByOldest.push(ideaIndex);
}
}
}
else {
// console.log('the case')
if (!myContractDb.publicStrategies.has(strategyUniqueKey)) {
myContractDb.publicStrategies.add(strategyUniqueKey);
myContractDb.publicStrategiesByOldest.push(strategyUniqueKey);
}
myContractDb.publicIdeaIndexByOldest.push(ideaIndex);
}
// console.log('===================================')
// console.log('===================================')
if (openSeaIdea.strategy.ordersType === 'ALLOCATION') {
// process allocation
if (!myContractDb.allocationStrategyPortfolios.has(strategyUniqueKey)) {
myContractDb.allocationStrategyPortfolios.set(strategyUniqueKey, {
strategyKey: strategyUniqueKey,
totalEntries: 0,
totalAllocation: 0,
entries: [],
});
}
if (myContractDb.allocationStrategyPortfolios.get(strategyUniqueKey) !==
'ENCRYPTED') {
const hasEncryption = openSeaIdea.access !== undefined;
if (hasEncryption) {
myContractDb.allocationStrategyPortfolios.set(strategyUniqueKey, 'ENCRYPTED');
}
else {
const innerIdea = openSeaIdea.idea;
const portfolio = myContractDb.allocationStrategyPortfolios.get(strategyUniqueKey);
// console.log('+++++++++++++++++++++++++++++++++++')
// console.log('++++++++++++ CALC PORTFOLIO +++++++')
// console.log('+++++++++++++++++++++++++++++++++++')
// console.log('PRIOR STEP: ')
// console.log('portfolio.totalEntries')
// console.log(portfolio.totalEntries)
// console.log('portfolio.totalAllocation')
// console.log(portfolio.totalAllocation)
// console.log('portfolio.entries')
// console.log(portfolio.entries)
// console.log('STEP:')
// console.log('innerIdea')
// console.log(innerIdea)
if (innerIdea.kind === 'open') {
portfolio.totalEntries++;
const portEntry = {
reference: openSeaIdea.content.reference,
pricing: openSeaIdea.pricing,
price: innerIdea.priceInfo.price,
notes: innerIdea.notes.commentary,
title: innerIdea.title,
asset: innerIdea.asset,
direction: innerIdea.trade?.direction,
allocation: innerIdea.trade.allocation,
};
portfolio.entries.push(portEntry);
portfolio.totalAllocation = +(0, bignumber_js_1.default)(portfolio.totalAllocation)
.plus(portEntry.allocation)
.toFixed(2);
}
else if (innerIdea.kind === 'adjust') {
const portEntry = portfolio.entries.find((entry) => entry.asset.ticker === innerIdea.asset.ticker);
portfolio.totalAllocation = +(0, bignumber_js_1.default)(portfolio.totalAllocation)
.minus(portEntry.allocation)
.toFixed(2);
portEntry.reference = openSeaIdea.content.reference;
portEntry.price = innerIdea.priceInfo.price;
portEntry.notes = innerIdea.notes.commentary;
portEntry.title = innerIdea.title || portEntry.title;
portEntry.asset = innerIdea.asset;
portEntry.direction =
innerIdea.trade?.direction || portEntry.direction;
if (innerIdea.adjustment.kind === 'increase') {
portEntry.allocation = +(0, bignumber_js_1.default)(portEntry.allocation)
.plus((0, bignumber_js_1.default)(portEntry.allocation).times((0, bignumber_js_1.default)(innerIdea.adjustment.percentage).dividedBy(100)))
.toFixed(2);
}
else {
portEntry.allocation = +(0, bignumber_js_1.default)(portEntry.allocation)
.minus((0, bignumber_js_1.default)(portEntry.allocation).times((0, bignumber_js_1.default)(innerIdea.adjustment.percentage).dividedBy(100)))
.toFixed(2);
}
portfolio.totalAllocation = +(0, bignumber_js_1.default)(portfolio.totalAllocation)
.plus(portEntry.allocation)
.toFixed(2);
}
else if (innerIdea.kind === 'close') {
const portEntryIndex = portfolio.entries.findIndex((entry) => entry.asset.ticker === innerIdea.asset.ticker);
if (portEntryIndex !== -1) {
portfolio.totalAllocation = +(0, bignumber_js_1.default)(portfolio.totalAllocation)
.minus(portfolio.entries[portEntryIndex].allocation)
.toFixed(2);
portfolio.entries.splice(portEntryIndex, 1);
portfolio.totalEntries--;
}
}
// console.log('AFTER STEP:')
// console.log('portfolio.totalEntries')
// console.log(portfolio.totalEntries)
// console.log('portfolio.totalAllocation')
// console.log(portfolio.totalAllocation)
// console.log('portfolio.entries')
// console.log(portfolio.entries)
// console.log('----------------------------')
// console.log('----------------------------')
// console.log('----------------------------')
// await rest(3000)
}
}
// console.log('_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_')
// console.log('_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_')
// console.log('_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_')
// console.log('_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_')
// console.log('openSeaIdea.idea as CI.ITradeIdeaIdea')
// console.log(openSeaIdea.idea as CI.ITradeIdeaIdea)
// console.log('openSeaIdea.content.reference')
// console.log(openSeaIdea.content.reference)
// process rebalances
const allocationRebalances = myContractDb.allocationRebalances.get(strategyUniqueKey);
if (allocationRebalances === undefined) {
const allocationRebalances = [];
allocationRebalances.push({
index: 0,
reference: openSeaIdea.content.reference,
ideaIndexes: [ideaIndex],
});
myContractDb.allocationRebalances.set(strategyUniqueKey, allocationRebalances);
}
else {
const lastOne = allocationRebalances[allocationRebalances.length - 1];
// console.log('lastOne')
// console.log(lastOne)
if (openSeaIdea.content.reference === lastOne.reference) {
lastOne.ideaIndexes.push(ideaIndex);
}
else {
allocationRebalances.push({
index: allocationRebalances.length,
reference: openSeaIdea.content.reference,
ideaIndexes: [ideaIndex],
});
}
}
// await rest(3000)
}
__1.LogModule.dev('-reduced-');
};
const listAllContracts = async () => {
// console.log('I HAVE BEEN')
// console.log('I HAVE BEEN')
// console.log('state.contractsByOldest')
// console.log(state.contractsByOldest)
return [...state.contractsByOldest];
};
const listAllStrategiesByContractAndUser = async (uniqueContractKey, userWallet) => {
// console.log('uniqueContractKey')
// console.log(uniqueContractKey)
// console.log('userWallet')
// console.log(userWallet)
// throw new Error('check')
const allStrategies = [
...(await listContractCreatorStrategies(uniqueContractKey, userWallet)),
...(await listContractUserWithAccessibleIdeasStrategies(uniqueContractKey, userWallet)),
...(await listContractWithPublicIdeasStrategies(uniqueContractKey)),
];
// filterOfDuplications without losing order
const seen = new Set();
const filtered = allStrategies.filter((item) => {
if (!seen.has(item)) {
seen.add(item);
return true;
}
return false;
});
return [...filtered];
};
const getStrategyLastIdea = async (uniqueStrategyReference) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyReference);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for strategy: ${uniqueStrategyReference}`);
}
const stg = myContractDb.ideaIndexByStrategyByOldest.get(uniqueStrategyReference);
if (!stg) {
throw new Error(`Strategy not found: ${uniqueStrategyReference}`);
}
const lastIdeaIndex = stg[stg.length - 1];
const ideaData = myContractDb.ideaIndexToData.get(lastIdeaIndex);
if (!ideaData) {
throw new Error(`Idea not found: ${lastIdeaIndex}`);
}
return (0, __1.copyObj)(ideaData);
};
const getStrategy = async (uniqueStrategyReference) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyReference);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for strategy: ${uniqueStrategyReference}`);
}
const stg = myContractDb.publicStrategiesFilled.get(uniqueStrategyReference);
if (!stg) {
throw new Error(`Strategy not found: ${uniqueStrategyReference}`);
}
return (0, __1.copyObj)(stg);
};
const getStrategyCreator = async (uniqueStrategyReference) => {
const lastIdea = await getStrategyLastIdea(uniqueStrategyReference);
return lastIdea.creator;
};
const getCreator = async (uniqueContractKey, creatorWallet) => {
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for creator: ${uniqueContractKey}`);
}
// console.log('creatorWallet')
// console.log(creatorWallet)
// console.log('myContractDb.creators')
// console.log(myContractDb.creators)
const creator = myContractDb.creators.get(creatorWallet);
if (!creator) {
throw new Error(`Creator not found: ${creatorWallet}`);
}
const lastIdea = creator.createdIdeasIndexesByOldest[creator.createdIdeasIndexesByOldest.length - 1];
const ideaData = myContractDb.ideaIndexToData.get(lastIdea);
if (!ideaData) {
throw new Error(`Idea not found: ${lastIdea}`);
}
return (0, __1.copyObj)(ideaData.creator);
};
const getStrategyWithCreator = async (uniqueStrategyReference) => {
const lastIdea = await getStrategyLastIdea(uniqueStrategyReference);
return (0, __1.copyObj)({
strategy: await getStrategy(uniqueStrategyReference),
creator: lastIdea.creator,
});
};
const listContractWithPublicIdeasStrategies = async (uniqueContractKey) => {
// console.log('uniqueContractKey')
// console.log(uniqueContractKey)
// console.log('state.contractDbs')
// console.log(state.contractDbs)
// console.log('dfhjasdfjkdhsflkasdhfjkhasdjk')
// console.log('dfhjasdfjkdhsflkasdhfjkhasdjk')
const myContractDb = state.contractDbs.get(uniqueContractKey);
// console.log('myContractDb')
// console.log(myContractDb)
if (myContractDb === undefined) {
return [];
}
// console.log('myContractDb.publicStrategiesByOldest')
// console.log(myContractDb.publicStrategiesByOldest)
// throw new Error('fads')
return [...myContractDb.publicStrategiesByOldest];
};
const listAllIdeasIndexesByStrategy = async (uniqueStrategyKey) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyKey);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found strategy: ${uniqueStrategyKey}`);
}
const stg = myContractDb.ideaIndexByStrategyByOldest.get(uniqueStrategyKey);
if (stg === undefined) {
return [];
}
return (0, __1.copyObj)(stg);
};
const listAllIdeasKeysByStrategy = async (uniqueStrategyKey) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyKey);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found strategy: ${uniqueStrategyKey}`);
}
const stg = myContractDb.ideaIndexByStrategyByOldest.get(uniqueStrategyKey);
if (stg === undefined) {
return [];
}
return [...stg.map((each) => myContractDb.ideaIndexToKeys.get(each))];
};
const listAllIdeasIndexesByContract = async (uniqueContractKey) => {
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
return [];
}
return [...myContractDb.ideaIndexByOldest];
};
const listAllPublicIdeasIndexesByContract = async (uniqueContractKey) => {
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
return [];
}
return [...myContractDb.publicIdeaIndexByOldest];
};
const listCreatedByIdeasIndexesByContract = async (uniqueContractKey, creatorWallet) => {
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
return [];
}
const creator = myContractDb.creators.get(creatorWallet);
if (creator === undefined) {
return [];
}
return [...creator.createdIdeasIndexesByOldest];
};
const listOwnedByIdeasIndexesByContract = async (uniqueContractKey, ownerWallet) => {
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
return [];
}
const ownerNfts = myContractDb.userAccessIdeaIndexesByOldest.get(ownerWallet);
if (ownerNfts === undefined) {
return [];
}
return [...ownerNfts];
};
const listOwnedByIdeasKeysByContract = async (uniqueContractKey, ownerWallet) => {
const indexes = await listOwnedByIdeasIndexesByContract(uniqueContractKey, ownerWallet);
const myContractDb = state.contractDbs.get(uniqueContractKey);
return [
...indexes.map((each) => {
return myContractDb.ideaIndexToKeys.get(each);
}),
];
};
const getIdeaKeys = async (ideaIndex) => {
const decomposed = (0, __1.uniqueKeySplit)(ideaIndex);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for idea: ${ideaIndex}`);
}
const myIdeaKeys = myContractDb.ideaIndexToKeys.get(ideaIndex);
if (myIdeaKeys === undefined) {
throw new Error(`Idea not found: ${ideaIndex}`);
}
return (0, __1.copyObj)(myIdeaKeys);
};
const getIdeaData = async (ideaIndex) => {
const decomposed = (0, __1.uniqueKeySplit)(ideaIndex);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for idea: ${ideaIndex}`);
}
const ideaData = myContractDb.ideaIndexToData.get(ideaIndex);
if (ideaData === undefined) {
throw new Error(`Idea not found: ${ideaIndex}`);
}
return (0, __1.copyObj)(ideaData);
};
const listContractCreatorStrategies = async (uniqueContractKey, creatorWallet) => {
const contractDb = state.contractDbs.get(uniqueContractKey);
if (!contractDb)
throw new Error('No contractDb found for uniqueContractKey: ' + uniqueContractKey);
const creator = contractDb.creators.get(creatorWallet);
if (!creator)
throw new Error('No creator found for creatorWallet: ' + creatorWallet);
// console.log('creator.strategiesByOldest')
// console.log(creator.strategiesByOldest)
// throw new Error('check')
return [...creator.strategiesByOldest];
};
const listContractUserWithAccessibleIdeasStrategies = async (uniqueContractKey, userWallet) => {
const contractDb = state.contractDbs.get(uniqueContractKey);
if (!contractDb)
throw new Error('No contractDb found for uniqueContractKey: ' + uniqueContractKey);
// console.log(userWallet)
const userAccessStrategies = contractDb.userAccessStrategies.get(userWallet);
// console.log('userAccessStrategies')
// console.log(userAccessStrategies)
if (userAccessStrategies === undefined)
return [];
return Array.from(userAccessStrategies);
};
const listContractUserSubscribedToIdeasStrategies = async (uniqueContractKey, userWallet) => {
const contractDb = state.contractDbs.get(uniqueContractKey);
if (!contractDb)
throw new Error('No contractDb found for uniqueContractKey: ' + uniqueContractKey);
const userAccessStrategies = contractDb.userSubscribedToStrategies.get(userWallet);
if (userAccessStrategies === undefined)
return [];
return Array.from(userAccessStrategies);
};
const listContractUserAccessibleIdeas = async (uniqueContractKey, userWallet) => {
const contractDb = state.contractDbs.get(uniqueContractKey);
if (!contractDb)
throw new Error('No contractDb found for uniqueContractKey: ' + uniqueContractKey);
const userAccessIdeaNfts = contractDb.userAccessIdeaNfts.get(userWallet);
if (userAccessIdeaNfts === undefined)
return [];
return Array.from(userAccessIdeaNfts);
};
const listContractUserAccessibleIdeasByStrategy = async (uniqueContractKey, userWallet, uniqueStrategyKey) => {
const contractDb = state.contractDbs.get(uniqueContractKey);
if (!contractDb)
throw new Error('No contractDb found for uniqueContractKey: ' + uniqueContractKey);
const userAccessIdeaKeysByStrategy = contractDb.userAccessIdeaKeysByStrategy.get(userWallet);
if (userAccessIdeaKeysByStrategy === undefined)
return [];
const userAccessIdeaKeys = userAccessIdeaKeysByStrategy.get(uniqueStrategyKey);
if (userAccessIdeaKeys === undefined)
return [];
return Array.from(userAccessIdeaKeys);
};
const getStrategyPortfolio = async (uniqueStrategyReference) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyReference);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for strategy: ${uniqueStrategyReference}`);
}
const portfolio = myContractDb.allocationStrategyPortfolios.get(uniqueStrategyReference);
if (portfolio === undefined) {
throw new Error(`Strategy not found: ${uniqueStrategyReference}`);
}
return (0, __1.copyObj)(portfolio);
};
const getStrategyRebalances = async (uniqueStrategyReference) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyReference);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for strategy: ${uniqueStrategyReference}`);
}
const rebalances = myContractDb.allocationRebalances.get(uniqueStrategyReference);
if (rebalances === undefined) {
throw new Error(`Strategy not found: ${uniqueStrategyReference}`);
}
return (0, __1.copyObj)(rebalances);
};
const getStrategyRebalance = async (uniqueStrategyReference, rebalanceReference) => {
const decomposed = (0, __1.uniqueKeySplit)(uniqueStrategyReference);
const uniqueContractKey = (0, __1.uniqueKeyJoin)([decomposed[0], decomposed[1]]);
const myContractDb = state.contractDbs.get(uniqueContractKey);
if (myContractDb === undefined) {
throw new Error(`Contract not found for strategy: ${uniqueStrategyReference}`);
}
const rebalances = myContractDb.allocationRebalances.get(uniqueStrategyReference);
if (rebalances === undefined) {
throw new Error(`Strategy not found: ${uniqueStrategyReference}`);
}
const rebalance = rebalances.find((rebalance) => rebalance.reference === rebalanceReference);
if (rebalance === undefined) {
throw new Error(`Rebalance not found: ${rebalanceReference}`);
}
return (0, __1.copyObj)(rebalance);
};
const getStrategyRebalancesInPeriod = async (uniqueStrategyReference, startDate, endDate) => {
const rebalances = await getStrategyRebalances(uniqueStrategyReference);
// First we filter out rebalances which reference cannot be parsed as a unix timestamp
// Then we include the parset timestamp on each rebalance
const isUnixTimestampString = (str) => {
const parsed = parseInt(str);
if (isNaN(parsed))
return false;
return parsed.toString() === str;
};
const rebalanceParsed = rebalances
.filter((rebalance) => isUnixTimestampString(rebalance.reference))
.map((rebalance) => {
return {
...rebalance,
timestamp: parseInt(rebalance.reference),
};
});
// now we filter ones between the dates
const rebalancesInPeriod = rebalanceParsed.filter((rebalance) => rebalance.timestamp >= startDate && rebalance.timestamp <= endDate);
return rebalancesInPeriod;
};
const contractsInMemoryDbView = {
reduce,
getStrategyLastIdea,
getStrategy,
getStrategyCreator,
getCreator,
getStrategyWithCreator,
listAllStrategiesByContractAndUser,
listAllIdeasIndexesByStrategy,
listAllIdeasKeysByStrategy,
listAllIdeasIndexesByContract,
listAllPublicIdeasIndexesByContract,
listCreatedByIdeasIndexesByContract,
listOwnedByIdeasIndexesByContract,
listOwnedByIdeasKeysByContract,
getIdeaKeys,
getIdeaData,
listAllContracts,
listContractWithPublicIdeasStrategies,
listContractCreatorStrategies,
listContractUserWithAccessibleIdeasStrategies,
listContractUserSubscribedToIdeasStrategies,
listContractUserAccessibleIdeasByStrategy,
listContractUserAccessibleIdeas,
getStrategyPortfolio,
getStrategyRebalances,
getStrategyRebalance,
getStrategyRebalancesInPeriod,
};
exports.contractsInMemoryDbView = contractsInMemoryDbView;
//# sourceMappingURL=contracts.dbview.js.map