@ixily/activ
Version:
Alpha Capture Trade Idea Verification. Blockchain ownership proven trade ideas and strategies.
867 lines (856 loc) • 40.1 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.rules = void 0;
const crypto_js_1 = __importDefault(require("crypto-js"));
const bignumber_js_1 = require("bignumber.js");
const __1 = require("../");
const __2 = require("../");
const getInitialStrategyState = (firstIdea) => {
const isPublic = typeof firstIdea.idea !== 'string';
const createdAt = firstIdea.strategy.createdAt;
firstIdea.strategy.changedAt = createdAt;
const state = {
strategy: {
...firstIdea.strategy,
createdAt,
changedAt: createdAt,
summaryCalc: undefined,
portfolio: undefined,
portfolioAllocated: undefined,
},
creator: {
name: firstIdea.creator.name,
company: firstIdea.creator.company,
url: firstIdea.creator.url,
companyLogo: firstIdea.creator.companyLogo,
// backgroundImage: firstIdea.creator.backgroundImage,
walletAddress: firstIdea.creator.walletAddress,
},
lastNftId: 0,
totalIdeas: 0,
lastValidatedNftId: 0,
totalValidatedIdeas: 0,
orderedIdeasNft: [],
ideas: new Map(),
encryptedIdeasByKey: new Map(),
validatedIdeasByKey: new Map(),
orderedEncryptedIdeaKeys: [],
encryptedIdeas: new Set(),
validatedIdeaKeys: new Set(),
notNullIdeasByKey: new Map(),
nullifiedStagesNft: new Set(),
percentagePublicValidated: 0,
allocationMap: new Map(),
totalAllocated: 0,
firstIdeaDateChecked: false,
};
return state;
};
// sort by nftId
const sortIdeasChronological = (strategyIdeas) => {
const ideasChronological = strategyIdeas.sort((a, b) => {
if (a.nftId === undefined)
return 1;
if (b.nftId === undefined)
return -1;
return a.nftId - b.nftId;
});
return ideasChronological;
};
const includeIdea = (ideaComplete, cachedStrategyState) => {
cachedStrategyState.ideas.set(ideaComplete.nftId, ideaComplete);
cachedStrategyState.totalIdeas++;
};
const includeEncryptedIdea = (ideaComplete, cachedStrategyState) => {
const ideaKey = ideaComplete.content.ideaKey;
if (cachedStrategyState.encryptedIdeasByKey.has(ideaKey)) {
cachedStrategyState.encryptedIdeasByKey
.get(ideaKey)
.push(ideaComplete.nftId);
}
else {
cachedStrategyState.encryptedIdeasByKey.set(ideaKey, [
ideaComplete.nftId,
]);
cachedStrategyState.orderedEncryptedIdeaKeys.push(ideaKey);
}
cachedStrategyState.encryptedIdeas.add(ideaComplete.nftId);
includeIdea(ideaComplete, cachedStrategyState);
};
const calculateTradeIdeaHash = (idea) => {
const ideaToCheck = { ...idea.idea };
// delete ideaToCheck.chainIdeas
// delete ideaToCheck.result
// console.log('ideaToCheck')
// console.log(ideaToCheck)
const deterministicIdeaString = __1.CONTRACT_TOOLS.deterministicStringify(ideaToCheck);
if (deterministicIdeaString === undefined) {
throw new Error('Calculate Idea Hash Error: deterministicIdeaString is undefined');
}
return crypto_js_1.default.SHA512(deterministicIdeaString).toString();
};
const retrievePastStages = (ideaComplete, cachedStrategyState) => {
// console.log('cachedStrategyState.validatedIdeasByKey')
// console.log(cachedStrategyState.validatedIdeasByKey)
// console.log('ideaComplete.content.ideaKey!')
// console.log(ideaComplete.content.ideaKey!)
const validatedOnSameKeyIdeas = cachedStrategyState.validatedIdeasByKey.get(ideaComplete.content.ideaKey);
// console.log('=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-')
// console.log('=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-')
// console.log('=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-')
// console.log('validatedOnSameKeyIdeas')
// console.log(validatedOnSameKeyIdeas)
const validatingIdeas = [];
for (const validatedOnSameKeyIdeaNftId of validatedOnSameKeyIdeas) {
const validatedIdea = cachedStrategyState.ideas.get(validatedOnSameKeyIdeaNftId);
validatingIdeas.push(validatedIdea);
}
// console.log('validatingIdeas')
// console.log(validatingIdeas)
return validatingIdeas;
};
const validateProccessPublicIdea = async (ideaComplete, cachedStrategyState) => {
const idea = ideaComplete.idea;
const alreadyMinted = ideaComplete.content.ideaKey !== undefined &&
ideaComplete.nftId !== undefined;
// console.log('idea')
// console.log(idea)
// console.log('alreadyMinted')
// console.log(alreadyMinted)
// console.log('ideaComplete.content.ideaKey')
// console.log(ideaComplete.content.ideaKey)
// console.log('ideaComplete.nftId')
// console.log(ideaComplete.nftId)
// console.log('ideaComplete.content.ideaKey!')
// console.log(ideaComplete.content.ideaKey!)
// console.log('cachedStrategyState.validatedIdeasByKey')
// console.log(
// cachedStrategyState.validatedIdeasByKey.get(
// ideaComplete.content.ideaKey!,
// ),
// )
// console.log('ideaComplete.nftId!')
// console.log(ideaComplete.nftId!)
let violation = undefined;
if (idea.kind !== 'open') {
if (ideaComplete.content.ideaKey === undefined) {
return 'The ideaKey is required.';
}
}
// console.log('ideaComplete pre')
// console.log(ideaComplete)
const validatingIdeas = idea.kind === 'open'
? []
: retrievePastStages(ideaComplete, cachedStrategyState);
// console.log('ideaComplete after')
// console.log(ideaComplete)
violation = (0, __2.validatePartialIdeaWithinSelf)([...validatingIdeas, ideaComplete], cachedStrategyState, !alreadyMinted);
if (violation !== undefined) {
return violation;
}
// validate pricing
const priceValidationResult = await __1.CONTRACT_TOOLS.validatePricingSignature(idea, cachedStrategyState);
if (!priceValidationResult.valid) {
violation = `The pricing signatures is not valid.`;
}
if (violation === undefined) {
setLastValidatedNftId(cachedStrategyState);
}
/*
// try to find the open ideaKey
const openIdeaSearch = cachedStrategyState.orderedIdeasNft
.filter(
(ones) => !cachedStrategyState.nullifiedStagesNft.has(ones),
)
.map(cachedStrategyState.ideas.get)
.reverse()
.find((one) => {
if (typeof one!.idea !== 'string') {
if ((one!.idea as ITradeIdeaIdea).kind === 'open') {
if (
(one!.idea as ITradeIdeaIdea).asset.ticker ===
(ideaComplete.idea as ITradeIdeaIdea).asset
.ticker
) {
return true
}
}
}
return false
})
if(openIdeaSearch === undefined) {
return `The ticker ${(ideaComplete.idea as ITradeIdeaIdea).asset.ticker} is not defined in the strategy.`
} else {
}
*/
return violation;
};
const validateProccessEncryptedIdea = async (ideaComplete, cachedStrategyState) => {
const alreadyMinted = ideaComplete.content.ideaKey !== undefined &&
ideaComplete.nftId !== undefined;
let violation = (0, __2.validatePartialIdeaEncryptedWithinSelf)(ideaComplete, cachedStrategyState, !alreadyMinted);
return violation;
};
const setLastValidatedNftId = (cachedStrategyState) => {
const orderedNotNull = cachedStrategyState.orderedIdeasNft
.filter((ones) => !cachedStrategyState.nullifiedStagesNft.has(ones))
.map((each) => cachedStrategyState.ideas.get(each));
let lastOne = 0;
for (const ordered of orderedNotNull) {
if (!cachedStrategyState.encryptedIdeasByKey.has(ordered.content.ideaKey)) {
lastOne = ordered.nftId;
}
else {
break;
}
}
cachedStrategyState.lastValidatedNftId = lastOne !== undefined ? lastOne : 0;
};
const validateProccessCloseDecryptIdea = async (ideaComplete, cachedStrategyState) => {
const idea = ideaComplete.idea;
const encryptedIdeaNfts = cachedStrategyState.encryptedIdeasByKey.get(ideaComplete.content.ideaKey);
const encryptedIdeas = [];
for (const encryptedIdeaNftId of encryptedIdeaNfts) {
const encryptedIdea = cachedStrategyState.ideas.get(encryptedIdeaNftId);
encryptedIdeas.push(encryptedIdea);
}
// validate close parts hashes
// check hashes
if (idea.chainIdeas === undefined) {
return `The chainIdeas is not defined in the content.`;
}
for (const chainedIdeaIndex in idea.chainIdeas) {
const chainedIdea = idea.chainIdeas[+chainedIdeaIndex];
let actualHash;
try {
actualHash = calculateTradeIdeaHash(chainedIdea);
}
catch (err) {
if (err.message)
return err.message;
throw err;
}
// console.log('chainedIdea')
// console.log(chainedIdea)
// console.log('actualHash')
// console.log(actualHash)
// console.log('chainedIdea.ideaSha512Hash')
// console.log(chainedIdea.ideaSha512Hash)
if (actualHash !== chainedIdea.ideaSha512Hash) {
return `The chainIdeas hashes are not valid.`;
}
const pastNftIdeaHash = encryptedIdeas[+chainedIdeaIndex].ideaSha512Hash;
if (pastNftIdeaHash !== chainedIdea.ideaSha512Hash) {
return `The chainIdeas hashes does not matches the past ones.`;
}
// This is happening two times. This was a duplication of the price validation happening
// inside validateCloseIdeaWithinSelf
// // validate pricing
// const priceValidationResult =
// await CONTRACT_TOOLS.validatePricingSignature(
// idea,
// cachedStrategyState,
// )
// if (!priceValidationResult.valid) {
// return `The pricing signatures are not valid.`
// }
}
// now we can trust the chained ideas, we can include them in the state
// and mark them as no more encrypted
for (const chainedIdeaIndex in idea.chainIdeas) {
const chainedIdea = idea.chainIdeas[+chainedIdeaIndex];
encryptedIdeas[+chainedIdeaIndex].idea = chainedIdea.idea;
cachedStrategyState.encryptedIdeas.delete(encryptedIdeas[+chainedIdeaIndex].nftId);
}
cachedStrategyState.encryptedIdeasByKey.delete(ideaComplete.content.ideaKey);
cachedStrategyState.orderedEncryptedIdeaKeys.splice(cachedStrategyState.orderedEncryptedIdeaKeys.indexOf(ideaComplete.content.ideaKey), 1);
// if it was th first idea ever, we check strategy timestamp
if (encryptedIdeas[0].nftId === cachedStrategyState.orderedIdeasNft[0]) {
if (encryptedIdeas[0].idea
.priceInfo.price.timestamp !==
cachedStrategyState.strategy.createdAt) {
return `The first idea timestamp does not match the strategy timestamp.`;
}
}
let violation = await (0, __2.validateCloseIdeaWithinSelf)([...encryptedIdeas, ideaComplete], cachedStrategyState);
if (violation === undefined) {
// We set last validated nft id
setLastValidatedNftId(cachedStrategyState);
}
return violation;
};
const validateProccessIdeaWithinChain = (ideaComplete, cachedStrategyState, preMint = false) => {
// console.log('cachedStrategyState.orderedIdeasNft')
// console.log(cachedStrategyState.orderedIdeasNft)
let valids = cachedStrategyState.orderedIdeasNft
.filter((ones) => !cachedStrategyState.nullifiedStagesNft.has(ones))
.filter((ones) => !cachedStrategyState.encryptedIdeas.has(ones))
.map((each) => cachedStrategyState.ideas.get(each));
cachedStrategyState.allocationMap = new Map();
cachedStrategyState.totalAllocated = 0;
valids = [...valids, ideaComplete];
// console.log('========================')
// console.log('========================')
// console.log('debug: validateProccessIdeaWithinChain')
// console.log('========================')
// console.log('========================')
// console.log('valids')
// console.log(valids)
const tickers = new Map();
// const tickersNftId = new Map<string, number>()
for (const valid of valids) {
const idea = valid.idea;
if (idea.kind === 'open') {
if (tickers.has(idea.asset.ticker)) {
// console.log('---------------------')
// console.log('---------------------')
// console.log('---------------------')
// console.log('The idea causing issues:')
// console.log('valid')
// console.log(valid)
// console.log('idea')
// console.log(idea)
// console.log('idea.asset')
// console.log(idea.asset)
// console.log('---------------------')
// console.log('---------------------')
// console.log('the previous idea conflict:')
// const nftId = tickersNftId.get(idea.asset.ticker)!
// console.log('nftId')
// console.log(nftId)
// const ideaV = cachedStrategyState.ideas.get(nftId)
// console.log('ideaV')
// console.log(ideaV)
// const ideaI = ideaV?.idea
// console.log('ideaI')
// console.log(ideaI)
// const ideaA = (ideaI as CONTRACT_INTERFACES.ITradeIdeaIdea)
// ?.asset
// console.log('ideaA')
// console.log(ideaA)
// const insideValids = valids.find((one) => one.nftId === nftId)
// console.log('insideValids')
// console.log(insideValids)
// console.log('--')
// console.log(insideValids?.idea)
// console.log('--')
// console.log(
// (insideValids?.idea as CONTRACT_INTERFACES.ITradeIdeaIdea)
// ?.asset,
// )
// throw new Error('stop')
return `The ticker ${idea.asset.ticker} is duplicated in the strategy.`;
}
else {
tickers.set(idea.asset.ticker, valid.content.ideaKey);
// tickersNftId.set(idea.asset.ticker, valid.nftId!)
}
if (cachedStrategyState.strategy.ordersType === 'ALLOCATION') {
if (idea.trade?.allocation === undefined) {
return `The ticker new open ALLOCATION idea requires trade allocation.`;
}
if (idea.trade.allocation <= 0 || idea.trade.allocation > 100) {
return `The ticker new open ALLOCATION idea requires trade allocation between 1 and 100.`;
}
if (idea.trade.conviction !== undefined) {
return `The ticker new open ALLOCATION idea requires trade conviction to be undefined.`;
}
// if (!preMint) {
// Adjust allocation after this idea
cachedStrategyState.allocationMap.set(idea.asset.ticker, 0 + idea.trade.allocation);
cachedStrategyState.totalAllocated = +(0, bignumber_js_1.BigNumber)(cachedStrategyState.totalAllocated)
.plus(idea.trade.allocation)
.toFixed(2);
// }
// check total allocation
if (cachedStrategyState.totalAllocated > 100) {
return `Idea Not Allowed: With this idea, the allocation would be greater than 100.`;
}
// update strategy
// if (!preMint) {
const portfolio = {};
for (const [ticker, allocation,] of cachedStrategyState.allocationMap.entries()) {
portfolio[ticker] = 0 + allocation;
}
cachedStrategyState.strategy.portfolio = portfolio;
cachedStrategyState.strategy.portfolioAllocated =
cachedStrategyState.totalAllocated;
// }
}
// Make sure if it was the first idea, it has the matching strategy date
if (!preMint && !cachedStrategyState.firstIdeaDateChecked) {
if (ideaComplete.content.ideaKey === undefined) {
throw new Error('ideaComplete.content.ideaKey is undefined');
}
if (ideaComplete.content.ideaKey === 0) {
if (idea.priceInfo?.price?.timestamp === undefined) {
return `The first idea timestamp is undefined.`;
}
if (cachedStrategyState.strategy.createdAt === undefined) {
return `The strategy timestamp is undefined.`;
}
if (idea.priceInfo.price.timestamp !==
cachedStrategyState.strategy.createdAt) {
return `The first idea timestamp does not match the strategy timestamp.`;
}
cachedStrategyState.firstIdeaDateChecked = true;
}
}
}
else if (idea.kind === 'adjust') {
// console.log('idea.asset.ticker')
// console.log(idea.asset.ticker)
// console.log('tickers')
// console.log(tickers)
if (tickers.get(idea.asset.ticker) === undefined) {
return `The ticker ${idea.asset.ticker} is not defined in the strategy.`;
}
if (tickers.get(idea.asset.ticker) !== valid.content.ideaKey) {
return `The ticker ${idea.asset.ticker} is not defined in the same stage.`;
}
if (cachedStrategyState.strategy.ordersType === 'ALLOCATION') {
// Adjust allocation after this idea
const previousAllocation = cachedStrategyState.allocationMap.get(idea.asset.ticker);
if (idea.adjustment.kind === 'increase') {
const newAllocation = +(0, bignumber_js_1.BigNumber)(previousAllocation)
.plus((0, bignumber_js_1.BigNumber)(previousAllocation).times((0, bignumber_js_1.BigNumber)(idea.adjustment.percentage).dividedBy(100)))
.toFixed(2);
// fix newAllocation max decimals to max between the adjustment and the previous allocation
// const previousAllocationDecimals =
// previousAllocation.toString().split('.')[1]?.length || 0
// const adjustmentDecimals =
// idea.adjustment!.percentage.toString().split('.')[1]
// ?.length || 0
// const maxDecimals = Math.max(
// previousAllocationDecimals,
// adjustmentDecimals,
// )
// newAllocation = parseFloat(
// newAllocation.toFixed(maxDecimals),
// )
// make sure newAllocation is not greater then 100
if (newAllocation > 100) {
return `Idea Not Allowed: With this idea, the allocation would be greater than 100.`;
}
cachedStrategyState.allocationMap.set(idea.asset.ticker, newAllocation);
// adjust total allocation
cachedStrategyState.totalAllocated = +(0, bignumber_js_1.BigNumber)(cachedStrategyState.totalAllocated)
.plus((0, bignumber_js_1.BigNumber)(newAllocation).minus(previousAllocation))
.toFixed(2);
}
else {
const newAllocation = +(0, bignumber_js_1.BigNumber)(previousAllocation)
.minus((0, bignumber_js_1.BigNumber)(previousAllocation).times((0, bignumber_js_1.BigNumber)(idea.adjustment.percentage).dividedBy(100)))
.toFixed(2);
// fix newAllocation max decimals to max between the adjustment and the previous allocation
// const previousAllocationDecimals =
// previousAllocation.toString().split('.')[1]?.length || 0
// const adjustmentDecimals =
// idea.adjustment!.percentage.toString().split('.')[1]
// ?.length || 0
// const maxDecimals = Math.max(
// previousAllocationDecimals,
// adjustmentDecimals,
// )
// newAllocation = parseFloat(
// newAllocation.toFixed(maxDecimals),
// )
// newAllocation = parseFloat(newAllocation.toFixed(2))
// make sure newAllocation is not zero
if (newAllocation <= 0) {
return `Idea Not Allowed: With this idea, the allocation would be zero.`;
}
cachedStrategyState.allocationMap.set(idea.asset.ticker, newAllocation);
// adjust total allocation
cachedStrategyState.totalAllocated = +(0, bignumber_js_1.BigNumber)(cachedStrategyState.totalAllocated)
.plus((0, bignumber_js_1.BigNumber)(newAllocation).minus(previousAllocation))
.toFixed(2);
}
// update strategy
const portfolio = {};
for (const [ticker, allocation,] of cachedStrategyState.allocationMap.entries()) {
portfolio[ticker] = 0 + allocation;
}
cachedStrategyState.strategy.portfolio = portfolio;
cachedStrategyState.strategy.portfolioAllocated =
cachedStrategyState.totalAllocated;
// check total allocation
if (cachedStrategyState.totalAllocated > 100) {
return `Idea Not Allowed: With this idea, the allocation would be greater than 100.`;
}
}
}
else {
if (tickers.get(idea.asset.ticker) === undefined) {
return `The ticker ${idea.asset.ticker} is not defined in the strategy.`;
}
if (tickers.get(idea.asset.ticker) !== valid.content.ideaKey) {
return `The ticker ${idea.asset.ticker} is not defined in the same stage.`;
}
if (cachedStrategyState.strategy.ordersType === 'ALLOCATION') {
// Adjust allocation after this idea
const previousAllocation = cachedStrategyState.allocationMap.get(idea.asset.ticker);
cachedStrategyState.totalAllocated = +(0, bignumber_js_1.BigNumber)(cachedStrategyState.totalAllocated)
.minus(previousAllocation)
.toFixed(2);
cachedStrategyState.allocationMap.delete(idea.asset.ticker);
// check total allocation
if (cachedStrategyState.totalAllocated > 100) {
return `Idea Not Allowed: With this idea, the allocation would be greater than 100.`;
}
// update strategy
const portfolio = {};
for (const [ticker, allocation,] of cachedStrategyState.allocationMap.entries()) {
portfolio[ticker] = 0 + allocation;
}
cachedStrategyState.strategy.portfolio = portfolio;
cachedStrategyState.strategy.portfolioAllocated =
cachedStrategyState.totalAllocated;
}
const openData = cachedStrategyState.ideas.get(cachedStrategyState.validatedIdeasByKey.get(tickers.get(idea.asset.ticker))[0]);
// include trade
idea.trade = {
direction: openData.idea
.trade.direction,
conviction: openData.idea.trade?.conviction,
allocation: openData.idea.trade?.allocation,
};
if (cachedStrategyState.strategy.ordersType === 'ALLOCATION') {
idea.trade.allocation = 0;
}
tickers.delete(idea.asset.ticker);
// tickersNftId.delete(idea.asset.ticker)
}
}
};
// Make sure idea access wallets list, if there, has the creator wallet
const validateWalletsAccessBasic = (ideaComplete, preMint = false) => {
if (ideaComplete.access !== undefined) {
if (ideaComplete.access.wallets.find((one) => one === ideaComplete.creator.walletAddress) === undefined) {
return `The creator wallet ${ideaComplete.creator.walletAddress} is not in the idea access wallets.`;
}
if (!preMint) {
if (ideaComplete.access.encryption === undefined) {
if (typeof ideaComplete.idea === 'string') {
return `The idea access encryption is undefined when expected to be filled.`;
}
else {
if (ideaComplete.idea.kind !== 'close') {
return `The idea access encryption is undefined when expected to be filled.`;
}
}
}
else {
if (ideaComplete.access.encryption.key === undefined) {
return `The idea access encryption key is undefined when expected to be filled.`;
}
else {
if (ideaComplete.access.encryption.key.length === 0) {
return `The idea access encryption key is empty when expected to be filled.`;
}
}
}
}
}
};
// Make sure all ideas access wallets in previous ideas are kept in this idea
const validateWalletsAccessKept = (ideaComplete, cachedStrategyState, preMint = false) => {
// aquire past ideas which should contain same ideaKey and ordered
const pastIdeas = __1.CONTRACT_TOOLS.queryChain.getAllIdeasByKey(ideaComplete.content.ideaKey, cachedStrategyState);
if (!preMint) {
pastIdeas.push(ideaComplete);
}
let pastWallets = pastIdeas[0]?.access?.wallets || ideaComplete.access?.wallets;
for (const pastIdeaIndex in pastIdeas) {
if (+pastIdeaIndex === 0) {
const pastIdea = pastIdeas[+pastIdeaIndex];
const currentWallets = pastIdea.access?.wallets;
if (currentWallets !== undefined) {
if (pastWallets === undefined) {
return `The wallet ${currentWallets} is not in the past idea access wallets.`;
}
}
else {
if (pastWallets !== undefined) {
return `The wallet ${pastWallets} is not in the current idea access wallets.`;
}
}
if (pastWallets !== undefined) {
// make sure all past wallets are in current wallets.
for (const pastWallet of pastWallets) {
if (!currentWallets.includes(pastWallet)) {
return `The wallet ${pastWallet} is not in the current idea access wallets.`;
}
}
// add current wallets to past wallets
for (const currentWallet of currentWallets) {
if (!pastWallets.includes(currentWallet)) {
pastWallets.push(currentWallet);
}
}
}
}
}
if (preMint) {
if (pastWallets !== undefined) {
if (ideaComplete.access?.wallets === undefined) {
ideaComplete.access = {
wallets: [],
};
}
const currentWallets = ideaComplete.access.wallets;
// make sure all past wallets are in current wallets. instead of returning an error, it will adds it to current
for (const pastWallet of pastWallets) {
if (!currentWallets.includes(pastWallet)) {
currentWallets.push(pastWallet);
}
}
}
else {
if (ideaComplete.access?.wallets !== undefined) {
delete ideaComplete.access;
}
}
}
};
const validateProccessIdeaWithinSelf = async (ideaComplete, ideaIsStringEncrypted, cachedStrategyState, preMint = false) => {
// console.log('::::::::::::::::::::::::::::::::::')
// console.log('::::::::::::::::::::::::::::::::::')
// console.log('::::::::::::::::::::::::::::::::::')
// console.log('overall Idea Complete')
// console.log(ideaComplete)
if (!ideaIsStringEncrypted) {
includeIdea(ideaComplete, cachedStrategyState);
const idea = ideaComplete.idea;
// if it is a close idea, we check it it is a closure of past private ideas
if (idea.kind === 'close') {
// we check it the close ideas is a closure of a past public know idea
// else
// search in state for encrypted by this idea key
if (cachedStrategyState.encryptedIdeasByKey.has(ideaComplete.content.ideaKey)) {
const violation = await validateProccessCloseDecryptIdea(ideaComplete, cachedStrategyState);
if (violation)
return violation;
/*
if (violation !== undefined) {
if (preMint) {
// return violation
return violation
} else {
// nullify the idea
ideaComplete.nullified = violation
cachedStrategyState.nullifiedStagesNft.add(
ideaComplete.nftId!,
)
cachedStrategyState.notNullIdeasByKey.delete(
ideaComplete.content.ideaKey!,
)
// We set last validated nft id
setLastValidatedNftId(cachedStrategyState)
}
}
*/
}
else {
// in this case we do validate the partial closed idea
const violation = await validateProccessPublicIdea(ideaComplete, cachedStrategyState);
if (violation)
return violation;
/*
if (violation) {
ideaComplete.nullified = violation
cachedStrategyState.nullifiedStagesNft.add(
ideaComplete.nftId!,
)
cachedStrategyState.notNullIdeasByKey.delete(
ideaComplete.content.ideaKey!,
)
setLastValidatedNftId(cachedStrategyState)
}
*/
}
}
else {
// if it is not a close idea, it is a public idea stage
// in this case we do validate the partial open/adjust stage
const violation = await validateProccessPublicIdea(ideaComplete, cachedStrategyState);
if (violation) {
return violation;
}
}
}
else {
if (!preMint || ideaComplete.nftId !== undefined) {
let violation = (0, __2.validateBasicEncryptedIdea)(ideaComplete, cachedStrategyState, preMint);
if (violation)
return violation;
violation = await validateProccessEncryptedIdea(ideaComplete, cachedStrategyState);
if (violation)
return violation;
includeEncryptedIdea(ideaComplete, cachedStrategyState);
}
}
// if (ideaComplete.nullified === undefined) {
let violation = validateWalletsAccessBasic(ideaComplete, preMint);
if (violation)
return violation;
violation = validateWalletsAccessKept(ideaComplete, cachedStrategyState, preMint);
if (violation)
return violation;
// }
return undefined;
};
/*
TODO: Efficiency path: shrinking:
URGENT => Make sure reuse cache everywhere! (checking)
(1) Observe useless data and try to create this roadpath: (DONE!) (...)
(2) We IPFSID-FY images and large files in the nft data PRIOR minting! (and access ipfsId before showing)! (DONE)
ToIpfsIdFy =>
ideaComplete.openSeaIdea.idea.public.image => ipfsId-fy
ideaComplete.openSeaIdea.image => eliminate
(3) After all idea proccess, prior return cache, remove all unused data that won't be used in the future validation anymore. (will do next maybe if still very big)
attention on the ideas encrypted that will be revisited by validation function after close and made public
effect 2: Search for functions outside this that uses this cache if they make use of any idea data you are about to delete first.
e2a: in case it does: try alternatives
Issued => getStrategyMetadata // src/modules/activ-v4/modules/chunks/activ-v4.module.ts
=> depends on the new queries complete
e2b: keep it =>> POSTPONED!
(5) Prior reading cache and After generating cache => Unzip-ish it/ Zip-ish it! => (will do next maybe if still very big)
Zip function that will:
a) exchange variables names by letters and small texts.
b) shrink/compact text values with ready to use on market packages made for this purpose.
(4) POSTPONED => Zip images and large files in the nft data PRIOR minting! (and unzip before showing) => POSTPONED
*/
const rules = async (strategyIdeas, cachedStrategyState, preMint = false) => {
// console.log('strategyIdeas[strategyIdeas.length - 2]')
// console.log(strategyIdeas[strategyIdeas.length - 2])
// console.log('strategyIdeas[strategyIdeas.length - 1]')
// console.log(strategyIdeas[strategyIdeas.length - 1])
// if (
// strategyIdeas[strategyIdeas.length - 1].nftId ===
// strategyIdeas[strategyIdeas.length - 2].nftId
// ) {
// }
if (strategyIdeas.length === 0) {
return 'Void Strategy';
}
const strategyIdeasChronological = sortIdeasChronological(strategyIdeas);
const firstIdea = strategyIdeasChronological[0];
if (firstIdea.strategy.ordersType === undefined) {
firstIdea.strategy.ordersType = 'STANDARD';
}
if (cachedStrategyState === undefined) {
cachedStrategyState = getInitialStrategyState(firstIdea);
}
// if (
// strategyIdeas[0].strategy.uniqueKey ===
// 'nAqta5S9H5M77y7pnmpeQqfxwpgJeiUsEYeJsMojG1UazoaauSKUhqDqH9fNdmqcJHZvm1eFogaatJBzojzSDB5cKci6CgxBwEEiSXT1xyawNBtDuddehhMh3ktLgWbyfpLtgoM49YevpVkyAMsjmmfwNVK8jUKcv'
// ) {
// console.log('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
// console.log('strategyIdeas[0].strategy')
// console.log(strategyIdeas[0].strategy)
// console.log('strategyIdeas[0].strategy.reference')
// console.log(strategyIdeas[0].strategy.reference)
// console.log('strategyIdeas[0].strategy.uniqueKey')
// console.log(strategyIdeas[0].strategy.uniqueKey)
// console.log('strategyIdeas')
// console.log(strategyIdeas)
// console.log('cachedStrategyState')
// console.log(cachedStrategyState)
// console.log('strategyIdeasChronological[0]')
// console.log(strategyIdeasChronological[0])
// }
// console.log('strategyIdeasChronological[0].nftId')
// console.log(strategyIdeasChronological[0].nftId)
// console.log('cachedStrategyState.lastNftId')
// console.log(cachedStrategyState.lastNftId)
// console.log('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&')
if (strategyIdeasChronological[0].nftId !== undefined) {
if (strategyIdeasChronological[0].nftId ===
cachedStrategyState.lastNftId) {
// we remove this idea
strategyIdeasChronological.shift();
}
}
// console.log('strategyIdeasChronological after shift')
// console.log(strategyIdeasChronological)
let violation = undefined;
for (const idea of strategyIdeasChronological) {
// console.log('idea')
// console.log(idea)
// const onlyValidate = idea.nftId === undefined
// console.log('preMint')
// console.log(preMint)
// console.log('idea.nftId')
// console.log(idea.nftId)
if ((!preMint || idea.nftId !== undefined) &&
idea.nullified === undefined) {
if (idea.nftId === undefined) {
return 'NFT ID is required';
}
if (idea.nftId < cachedStrategyState.lastNftId) {
return 'NFT ID must be greater than last NFT ID';
}
}
if (idea.nullified !== undefined && !preMint) {
cachedStrategyState.nullifiedStagesNft.add(idea.nftId);
}
if (idea.nullified === undefined) {
// bellow is not true if idea is nullified due to error in middle of creation
const ideaIsStringEncrypted = typeof idea.idea === 'string';
if (idea.access?.encryption?.encrypt !== true &&
ideaIsStringEncrypted) {
return 'If the idea is string, it should figure as encrypted.';
}
// console.log('ideaIsStringEncrypted:')
// console.log(ideaIsStringEncrypted)
violation = await validateProccessIdeaWithinSelf(idea, ideaIsStringEncrypted, cachedStrategyState, preMint);
if (violation) {
return violation;
}
if (!ideaIsStringEncrypted && idea.nullified === undefined) {
violation = validateProccessIdeaWithinChain(idea, cachedStrategyState, preMint);
if (violation) {
/*
if (preMint) {
// return violation
return violation
} else {
// nullify the idea
idea.nullified = violation
cachedStrategyState.nullifiedStagesNft.add(idea.nftId!)
cachedStrategyState.notNullIdeasByKey.delete(
idea.content.ideaKey!,
)
setLastValidatedNftId(cachedStrategyState)
}
*/
return violation;
}
}
if (!preMint || idea.nftId !== undefined) {
// console.log('adding to ordered nfts')
// console.log('idea')
// console.log(idea)
// if (idea.nullified === undefined) {
cachedStrategyState.orderedIdeasNft.push(idea.nftId);
// }
cachedStrategyState.lastNftId = idea.nftId;
// console.log('cachedStrategyState.orderedIdeasNft')
// console.log(cachedStrategyState.orderedIdeasNft)
// console.log('cachedStrategyState.lastNftId')
// console.log(cachedStrategyState.lastNftId)
}
}
}
/** **/
return {
valid: true,
cachedStrategyState,
};
};
exports.rules = rules;
//# sourceMappingURL=ixily-activ-rules-v4.module.js.map