@ixily/activ/dist/contract/tools/chunks/query-chain.tools.js

Alpha Capture Trade Idea Verification. Blockchain ownership proven trade ideas and strategies.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getAllStillNotClosedLatestIdeas = exports.getOnlyLastStageOfEachIdea = exports.getCreatorLatestData = exports.getLastIdea = exports.getExistingCloseNftByTicker = exports.getExistingAdjustNftByTicker = exports.getExistingOpenNftByTicker = exports.getFirstStageOfIdeaByKey = exports.getLastStageOfIdeaByKey = exports.getAllIdeasByKey = exports.getAllIdeas = exports.getEncryptedIdeasByKey = exports.getEncryptedIdeas = exports.getValidatedIdeasByKey = exports.getValidatedIdeas = exports.sanitizeIdeas = exports.filterDuplicatedIdeas = exports.filterNullifiedIdeas = exports.orderByNftId = void 0;
// order by nftId. if nftId is undefined, put it at the end
const orderByNftId = (ideas) => {
    const orderedIdeas = ideas.sort((a, b) => {
        if (a.nftId === undefined && b.nftId === undefined)
            return 0;
        if (a.nftId === undefined)
            return 1;
        if (b.nftId === undefined)
            return -1;
        return a.nftId - b.nftId;
    });
    return orderedIdeas;
};
exports.orderByNftId = orderByNftId;
const filterNullifiedIdeas = (ideas) => {
    const filteredIdeas = ideas.filter((idea) => idea.nullified === undefined);
    return filteredIdeas;
};
exports.filterNullifiedIdeas = filterNullifiedIdeas;
const filterDuplicatedIdeas = (ideas) => {
    const alreadySeenNftIds = new Set();
    const filteredIdeas = [];
    for (const idea of ideas) {
        if (idea.nftId === undefined)
            continue;
        if (alreadySeenNftIds.has(idea.nftId))
            continue;
        alreadySeenNftIds.add(idea.nftId);
        filteredIdeas.push(idea);
    }
    return filteredIdeas;
};
exports.filterDuplicatedIdeas = filterDuplicatedIdeas;
const sanitizeIdeas = (ideas) => {
    return (0, exports.orderByNftId)((0, exports.filterDuplicatedIdeas)((0, exports.filterNullifiedIdeas)(ideas)));
};
exports.sanitizeIdeas = sanitizeIdeas;
const getValidatedIdeas = (cachedStrategyState) => {
    let validatedIdeas = [];
    const check = cachedStrategyState?.validatedIdeaKeys;
    if (check) {
        for (const validatedIdeaKey of cachedStrategyState.validatedIdeaKeys.values()) {
            const validatedIdeaSet = (0, exports.getValidatedIdeasByKey)(validatedIdeaKey, cachedStrategyState);
            validatedIdeas = [...validatedIdeas, ...validatedIdeaSet];
        }
    }
    return (0, exports.sanitizeIdeas)(validatedIdeas);
};
exports.getValidatedIdeas = getValidatedIdeas;
const getValidatedIdeasByKey = (ideaKey, cachedStrategyState) => {
    const validatedIdeas = [];
    const check = cachedStrategyState?.validatedIdeasByKey;
    if (check) {
        const validatedIdeasNftIds = cachedStrategyState.validatedIdeasByKey.get(ideaKey) || [];
        for (const validatedIdeaNftId of validatedIdeasNftIds) {
            const validatedIdea = cachedStrategyState.ideas.get(validatedIdeaNftId);
            validatedIdeas.push(validatedIdea);
        }
    }
    return (0, exports.sanitizeIdeas)(validatedIdeas);
};
exports.getValidatedIdeasByKey = getValidatedIdeasByKey;
const getEncryptedIdeas = (cachedStrategyState) => {
    const encryptedIdeas = [];
    const check = cachedStrategyState?.encryptedIdeas;
    if (check) {
        const encryptedIdeasNftIds = cachedStrategyState.encryptedIdeas.values();
        for (const encryptedIdeaNftId of encryptedIdeasNftIds) {
            const encryptedIdea = cachedStrategyState.ideas.get(encryptedIdeaNftId);
            encryptedIdeas.push(encryptedIdea);
        }
    }
    return (0, exports.sanitizeIdeas)(encryptedIdeas);
};
exports.getEncryptedIdeas = getEncryptedIdeas;
const getEncryptedIdeasByKey = (ideaKey, cachedStrategyState) => {
    const encryptedIdeas = [];
    const check = cachedStrategyState?.encryptedIdeasByKey;
    if (check) {
        const encryptedIdeasNftIds = cachedStrategyState.encryptedIdeasByKey.get(ideaKey) || [];
        for (const encryptedIdeaNftId of encryptedIdeasNftIds) {
            const encryptedIdea = cachedStrategyState.ideas.get(encryptedIdeaNftId);
            encryptedIdeas.push(encryptedIdea);
        }
    }
    return (0, exports.sanitizeIdeas)(encryptedIdeas);
};
exports.getEncryptedIdeasByKey = getEncryptedIdeasByKey;
const getAllIdeas = (cachedStrategyState) => {
    const allIdeas = [
        ...(0, exports.getValidatedIdeas)(cachedStrategyState),
        ...(0, exports.getEncryptedIdeas)(cachedStrategyState),
    ];
    return (0, exports.sanitizeIdeas)(allIdeas);
};
exports.getAllIdeas = getAllIdeas;
const getAllIdeasByKey = (ideaKey, cachedStrategyState) => {
    const allIdeas = [
        ...(0, exports.getValidatedIdeasByKey)(ideaKey, cachedStrategyState),
        ...(0, exports.getEncryptedIdeasByKey)(ideaKey, cachedStrategyState),
    ];
    return (0, exports.sanitizeIdeas)(allIdeas);
};
exports.getAllIdeasByKey = getAllIdeasByKey;
const getLastStageOfIdeaByKey = (ideaKey, cachedStrategyState) => {
    const lastStageOfIdea = (0, exports.getAllIdeasByKey)(ideaKey, cachedStrategyState).pop();
    return lastStageOfIdea;
};
exports.getLastStageOfIdeaByKey = getLastStageOfIdeaByKey;
const getFirstStageOfIdeaByKey = (ideaKey, cachedStrategyState) => {
    const firstStageOfIdea = (0, exports.getAllIdeasByKey)(ideaKey, cachedStrategyState).shift();
    return firstStageOfIdea;
};
exports.getFirstStageOfIdeaByKey = getFirstStageOfIdeaByKey;
const getExistingOpenNftByTicker = (ticker, cachedStrategyState) => {
    const valids = (0, exports.getAllIdeas)(cachedStrategyState);
    const tickersMapOpenNftId = new Map();
    for (const valid of valids) {
        if (valid.idea === undefined)
            continue;
        const idea = valid.idea;
        if (idea.kind === 'open') {
            tickersMapOpenNftId.set(idea.asset.ticker, valid.nftId);
        }
        else if (idea.kind === 'close') {
            tickersMapOpenNftId.delete(idea.asset.ticker);
        }
    }
    if (tickersMapOpenNftId.has(ticker)) {
        return cachedStrategyState.ideas.get(tickersMapOpenNftId.get(ticker));
    }
    else {
        return undefined;
    }
};
exports.getExistingOpenNftByTicker = getExistingOpenNftByTicker;
const getExistingAdjustNftByTicker = (ticker, cachedStrategyState) => {
    const valids = (0, exports.getAllIdeas)(cachedStrategyState);
    let lookingForNftId = undefined;
    const tickersMapOpenNftId = new Map();
    for (const valid of valids) {
        if (valid.idea === undefined)
            continue;
        const idea = valid.idea;
        if (idea.kind === 'open') {
            tickersMapOpenNftId.set(idea.asset.ticker, valid.nftId);
        }
        else if (idea.kind === 'adjust') {
            lookingForNftId = valid.nftId;
        }
        else if (idea.kind === 'close') {
            tickersMapOpenNftId.delete(idea.asset.ticker);
            lookingForNftId = undefined;
        }
    }
    if (tickersMapOpenNftId.has(ticker) && lookingForNftId !== undefined) {
        return cachedStrategyState.ideas.get(lookingForNftId);
    }
    else {
        return undefined;
    }
};
exports.getExistingAdjustNftByTicker = getExistingAdjustNftByTicker;
const getExistingCloseNftByTicker = (ticker, cachedStrategyState) => {
    const valids = (0, exports.getAllIdeas)(cachedStrategyState);
    let lookingForNftId = undefined;
    const tickersMapOpenNftId = new Map();
    for (const valid of valids) {
        if (valid.idea === undefined)
            continue;
        const idea = valid.idea;
        if (idea.kind === 'open') {
            lookingForNftId = undefined;
            tickersMapOpenNftId.set(idea.asset.ticker, valid.nftId);
        }
        else if (idea.kind === 'adjust') {
        }
        else if (idea.kind === 'close') {
            lookingForNftId = valid.nftId;
            tickersMapOpenNftId.delete(idea.asset.ticker);
        }
    }
    if (!tickersMapOpenNftId.has(ticker) && lookingForNftId !== undefined) {
        return cachedStrategyState.ideas.get(lookingForNftId);
    }
    else {
        return undefined;
    }
};
exports.getExistingCloseNftByTicker = getExistingCloseNftByTicker;
const getLastIdea = (cachedStrategyState) => {
    return cachedStrategyState.ideas.get(cachedStrategyState.lastNftId);
};
exports.getLastIdea = getLastIdea;
const getCreatorLatestData = (cachedStrategyState) => {
    const lastIdea = (0, exports.getLastIdea)(cachedStrategyState);
    const creator = lastIdea.creator;
    return creator;
};
exports.getCreatorLatestData = getCreatorLatestData;
const getOnlyLastStageOfEachIdea = (cachedStrategyState) => {
    const allOrderedIdeas = (0, exports.getAllIdeas)(cachedStrategyState);
    const allLatestIdeas = new Map();
    for (const idea of allOrderedIdeas) {
        allLatestIdeas.set(idea.content.ideaKey, idea);
    }
    const latestStages = Array.from(allLatestIdeas.values());
    // now order it again
    const orderedLatestStages = latestStages.sort((a, b) => {
        if (a.nftId === undefined && b.nftId === undefined)
            return 0;
        if (a.nftId === undefined)
            return 1;
        if (b.nftId === undefined)
            return -1;
        return a.nftId - b.nftId;
    });
    return orderedLatestStages;
};
exports.getOnlyLastStageOfEachIdea = getOnlyLastStageOfEachIdea;
const getAllStillNotClosedLatestIdeas = (cachedStrategyState) => {
    const allLatestStages = (0, exports.getOnlyLastStageOfEachIdea)(cachedStrategyState);
    return allLatestStages.filter((ones) => {
        if (typeof ones.idea === 'string') {
            return true;
        }
        else {
            const idea = ones.idea;
            if (idea.kind === 'close') {
                return false;
            }
            else {
                return true;
            }
        }
    });
};
exports.getAllStillNotClosedLatestIdeas = getAllStillNotClosedLatestIdeas;
//# sourceMappingURL=query-chain.tools.js.map