@ixily/activ/src/sdk/activ-v4/modules/chunks/activ-v4.module.ts

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

import { ConfigModule } from './config.module'
import { ContractModule } from './contract.module'
import { CryptoIdeasModule } from './crypto-ideas.module'
import { LitModule } from './lit.module'
import { ProvableIdeasModule } from './provable-ideas.module'
import { StrategyChainModule } from './strategy-chain.module'

import { version } from '../../../version.json'
import { contractDbVersion } from '../../../version-contract-db.json'

// temporary
import { MigrationV3TemporaryModule } from './migration-v3.module'

import {
	CONTRACT_INTERFACES,
	CacheService,
	Contract,
	IContract,
	IMessContractSpecs,
	// IActivConfig,
	IOperationalCost,
	IPaging,
	IStrategyChain,
	MessModule,
	MyMessDbServer,
	OperationalCostModule,
	PricingModule,
	ethers,
	skipExpirationInSeconds,
} from '../../'
import {
	ACTIV_AVAILABLE_CHAINS,
	ACTIV_LIVE_CHAINS,
} from '../../constants/chunks/contracts'
import { QueryViewsModule } from './query-views.module'
import { ITradeIdeaIdea } from 'contract/interfaces'

const config = ConfigModule.config

const listContractChains = ContractModule.listBlockchainNetworks
const listContractsForChain = ContractModule.listContractsForNetwork
const selectChainContract = ContractModule.changeToContract
const getBlockchainContract = ContractModule.getBlockchainContract
const getGateContract = (): Contract | undefined => ContractModule.getGate()

const getIdeaByNftId = async (
	ideaNft: number,
	decrypt: boolean = true,
	inflateImages: boolean = false,
	contract?: IContract,
) => {
	contract = ContractModule.thisOrGet(contract)
	const key = `getIdeaByNftId_${ideaNft}_${decrypt}`
	const { data } = await CacheService.getData({
		contract: contract?.gate,
		key,
		init: async () => {
			return ProvableIdeasModule.general.getIdeaByNftId(
				ideaNft,
				decrypt,
				inflateImages,
				contract,
			)
		},
	})

	if (MigrationV3TemporaryModule.isCloseIdea(data)) {
		await CacheService.updateData({
			key,
			contract: contract?.gate,
			data,
			expirationInSeconds: skipExpirationInSeconds,
		})
	}

	return data
}

const getIdeaMetadataByKeys = async (
	strategyKey: string,
	ideaKey: number,
	stageKey: number,
	creator?: string,
	contract?: IContract,
): Promise<string> =>
	ProvableIdeasModule.general.getIdeaMetadataByKeys(
		strategyKey,
		ideaKey,
		stageKey,
		creator,
		contract,
	)

const getIdeaNftIdByKeys = async (
	creator: string,
	strategyKey: string,
	ideaKey: number,
	stageKey: number,
	contract?: IContract,
): Promise<number> =>
	ProvableIdeasModule.general.getIdeaNftIdByKeys(
		creator,
		strategyKey,
		ideaKey,
		stageKey,
		contract,
	)

const getIdeaByKeys = async (
	strategyKey: string,
	ideaKey: number,
	stageKey: number,
	creator?: string,
	contract?: IContract,
): Promise<CONTRACT_INTERFACES.ITradeIdea> =>
	ProvableIdeasModule.general.getIdeaByKeys(
		strategyKey,
		ideaKey,
		stageKey,
		creator,
		contract,
	)

// const listAllStrategies = async (contract?: IContract): Promise<any[]> =>
// 	ProvableIdeasModule.general.listAllStrategies(contract)

const updateCurrentContractDb = async (contract?: IContract) => {
	contract = ContractModule.thisOrGet(contract)
	await MessModule.updateContractDb(contract)
}

const serveContractsDb = async (
	chainContracts: IMessContractSpecs[],
): Promise<MyMessDbServer[]> => {
	return MessModule.serveContractsDb(chainContracts)
}

const readEvents = async () => ProvableIdeasModule.canonical.readEvents()

const listStrategyReferences = async (
	creator?: string,
	contract?: IContract,
): Promise<string[]> =>
	ProvableIdeasModule.canonical.listStrategyReferences(creator, contract)

const getStrategyIdeasCanonical = async (
	strategyReference: string,
	creator?: string,
	contract?: IContract,
): Promise<CONTRACT_INTERFACES.ITradeIdea[]> =>
	ProvableIdeasModule.canonical.getStrategyIdeasCanonical(
		strategyReference,
		creator,
		contract,
	)

// const listCreatorAndStrategyReferences = async (
// 	creator?: string,
// 	contract?: IContract,
// ): Promise<IOrderedReference> =>
// 	ProvableIdeasModule.canonical.listCreatorAndStrategyReferences(
// 		creator,
// 		contract,
// 	)

const listStrategyReferencesCanonical = async (
	creator?: string,
	contract?: IContract,
): Promise<string[]> =>
	ProvableIdeasModule.canonical.listStrategyReferencesCanonical(
		creator,
		contract,
	)

const listStrategiesDetailsCanonical = async (
	creator?: string,
	contract?: IContract,
): Promise<CONTRACT_INTERFACES.ITradeIdeaStrategy[]> =>
	ProvableIdeasModule.canonical.listStrategiesDetailsCanonical(
		creator,
		contract,
	)

const listAllIdeasCanonical = async (
	creator?: string,
	contract?: IContract,
): Promise<CONTRACT_INTERFACES.ITradeIdea[]> =>
	ProvableIdeasModule.canonical.listIdeasCanonical(creator, contract)

// We can proide the creator address to get from the strategies otherwise it defaults to the current user
const listStrategiesByCreator = async (
	creator?: string,
	contract?: IContract,
): Promise<any[]> =>
	ProvableIdeasModule.general.listStrategies(creator, contract)

/*
const getAllIdeas = async (
	creator?: string,
	contract?: IContract,
): Promise<any[]> => {
*/

const getMetadataByBlockId = async (
	blockId: number,
	decryptIdea?: boolean,
	contract?: IContract,
) =>
	ProvableIdeasModule.general.getMetadataByBlockId(
		blockId,
		decryptIdea,
		contract,
	)

const listStrategyIdeasByCreatorAndReference = async (
	strategyReference: string,
	creator?: string,
	contract?: IContract,
): Promise<number[]> => {
	const { data } = await CacheService.getData({
		contract: contract?.gate,
		key: `listIdeas_${strategyReference}`,
		init: async () => {
			return ProvableIdeasModule.general.listIdeas(
				strategyReference,
				creator,
				contract,
			)
		},
	})
	return data
}

const listStrategyIdeasStagesByCreatorAndReference = async (
	strategyReference: string,
	ideaKey: number,
	creator?: string,
	contract?: IContract,
): Promise<number[]> =>
	ProvableIdeasModule.general.listStages(
		strategyReference,
		ideaKey,
		creator,
		contract,
	)

const getCurrentStrategyTickers = async (
	strategyChainOrStrategyKey: IStrategyChain | string,
	creator?: string,
	contract?: IContract,
): Promise<
	{
		ticker: string
		ideaKey: number
	}[]
> => {
	const { data } = await CacheService.getData({
		contract: contract?.gate,
		key: `getCurrentStrategyTickers_${
			(strategyChainOrStrategyKey as IStrategyChain)?.strategyKey ||
			strategyChainOrStrategyKey
		}`,
		init: async () => {
			return ProvableIdeasModule.general.getCurrentStrategyTickers(
				strategyChainOrStrategyKey,
				creator,
				contract,
			)
		},
	})
	return data
}

const getStrategyChain = async (
	strategyKey: string,
	creator?: string,
	contract?: IContract,
): Promise<IStrategyChain> =>
	ProvableIdeasModule.general.getStrategyChain(strategyKey, creator, contract)

const getValidatedStrategyChain = async (
	strategyKey: string,
	creator?: string,
	contract?: IContract,
): Promise<IStrategyChain> =>
	ProvableIdeasModule.general.getValidatedStrategyChain(
		strategyKey,
		creator,
		contract,
	)

const getStrategyMetadata = async (
	strategyChain?: IStrategyChain,
	strategyKey?: string,
	creator?: string,
	contract?: IContract,
): Promise<CONTRACT_INTERFACES.ITradeIdeaStrategy> => {
	if (strategyChain === undefined) {
		strategyChain = await getValidatedStrategyChain(
			strategyKey!,
			creator,
			contract,
		)
	}

	let strategyMetadata: CONTRACT_INTERFACES.ITradeIdeaStrategy | undefined =
		undefined
	let reverseSeachIndex: number = 1
	while (strategyMetadata === undefined) {
		const lastIdea =
			strategyChain.ideas[strategyChain.ideas.length - reverseSeachIndex]
		strategyMetadata =
			lastIdea.stages[lastIdea.stages.length - 1].ideaStage.strategy
	}
	return strategyMetadata
}

// const getOwnedByNfts = async (
// 	owner?: string,
// 	contract?: IContract,
// ): Promise<any> => ProvableIdeasModule.general.getOwnedByNfts(owner, contract)
//
// const getCreatedByNfts = async (
// 	creator?: string,
// 	contract?: IContract,
// ): Promise<number[]> =>
// 	ProvableIdeasModule.general.getCreatedByNfts(creator, contract)

/*
 * Get all ideas created by a wallet address user
 *
 * creator defaults to the caller
 *
 * @param {string} creator
 * @param {number} page
 * @param {number} limit
 * @param {Contract} contract
 * @returns {Promise<any[]>}
 */
// const getCreatedByIdeas = async (
// 	page: number = 1,
// 	limit: number = 5,
// 	creator?: string,
// 	contract?: IContract,
// ): Promise<IPaging<IOpenSeaMetadata>> =>
// 	ProvableIdeasModule.general.getCreatedByIdeas(
// 		creator,
// 		page,
// 		limit,
// 		undefined,
// 		contract,
// 	)

const getMyIdeas = async (
	page: number = 1,
	limit: number = 5,
	contract?: IContract,
): Promise<IPaging<CONTRACT_INTERFACES.ITradeIdea>> =>
	ProvableIdeasModule.general.getCreatedByIdeas(
		undefined,
		page,
		limit,
		undefined,
		contract,
	)

// const getMyIdeasByFilter = async (
// 	page: number = 1,
// 	limit: number = 5,
// 	filterIdeaKind: ITradeIdeaIdeaKind,
// 	contract?: IContract,
// ): Promise<IPaging<any>> =>
// 	ProvableIdeasModule.general.getCreatedByIdeas(
// 		undefined,
// 		page,
// 		limit,
// 		filterIdeaKind,
// 		contract,
// 	)

/*
 * Get all ideas owned by a wallet address user
 *
 * creator defaults to the caller
 *
 * @param {string} creator
 * @param {number} page
 * @param {number} limit
 * @param {Contract} contract
 * @returns {Promise<any[]>}
 */
// const getOwnedByIdeas = async (
// 	page: number = 1,
// 	limit: number = 5,
// 	creator?: string,
// 	contract?: IContract,
// ): Promise<IPaging<any>> =>
// 	ProvableIdeasModule.general.getOwnedByIdeas(
// 		creator,
// 		page,
// 		limit,
// 		undefined,
// 		contract,
// 	)

const getAllIdeasUserCanSee = async (
	page: number = 1,
	limit: number = 5,
	user?: string,
	contract?: IContract,
): Promise<IPaging<any>> =>
	ProvableIdeasModule.general.getAllIdeasUserCanSee(
		user,
		page,
		limit,
		undefined,
		contract,
	)

const getAllMyIdeas = async (
	page: number = 1,
	limit: number = 5,
	contract?: IContract,
): Promise<IPaging<any>> =>
	ProvableIdeasModule.general.getAllIdeasUserCanSee(
		undefined,
		page,
		limit,
		undefined,
		contract,
	)

// const getAllPublicIdeas = async (
// 	page: number = 1,
// 	limit: number = 5,
// 	contract?: IContract,
// ): Promise<IPaging<any>> =>
// 	ProvableIdeasModule.general.getAllPublicClosedIdeas(page, limit, contract)

const testPricingAsset = async (
	request: CONTRACT_INTERFACES.IProviderRequest,
): Promise<CONTRACT_INTERFACES.IPrice> =>
	PricingModule.testPricingAsset(request)

const settings = async (contract?: IContract) =>
	ContractModule.getWalletSettings(contract)

const supportedChainNetworks = () => ACTIV_AVAILABLE_CHAINS

const getEstimatedCosts = async (
	newIdea: boolean = true,
	clientInBehalf?: string,
	contract?: IContract,
): Promise<IOperationalCost> => {
	contract = await ContractModule.thisOrGet(contract)
	return OperationalCostModule.getEstimatedCosts(
		contract,
		clientInBehalf,
		newIdea,
	)
}

const createPortfolioEntry =
	ProvableIdeasModule?.clientOnly?.createPortfolioEntry
const createPortfolio = ProvableIdeasModule?.clientOnly?.createPortfolio
const createIdea = ProvableIdeasModule?.clientOnly?.createIdea
const createNormalizedTradeIdea =
	ProvableIdeasModule?.clientOnly?.createNormalizedTradeIdea
const adjustIdea = ProvableIdeasModule?.clientOnly?.adjustIdea
const closeIdea = ProvableIdeasModule?.clientOnly?.closeIdea

const providerCreateIdea = ProvableIdeasModule.providerOnly.providerCreateIdea
const providerCloseIdea = ProvableIdeasModule.providerOnly.providerCloseIdea
const providerAdjustIdea = ProvableIdeasModule.providerOnly.providerAdjustIdea
const providerCreateFiatMintIdea =
	ProvableIdeasModule.providerOnly.providerCreateFiatMintIdea

const createIdeaFromFiatMint = ProvableIdeasModule?.fiatMint?.createIdea
const createNormalizedTradeIdeaFromFiatMint =
	ProvableIdeasModule?.fiatMint?.createNormalizedTradeIdea
const adjustIdeaFromFiatMint = ProvableIdeasModule?.fiatMint?.adjustIdea
const closeIdeaFromFiatMint = ProvableIdeasModule?.fiatMint?.closeIdea

const getCreatorOfNftIdea = async (nftId: number, contract?: IContract) =>
	ProvableIdeasModule.general.getCreatorOfNftIdea(nftId, contract)

const restoredIdeasWithPagination =
	CryptoIdeasModule.getRestoredIdeasByNftIdsWithPaginationAndFilter
const restoreIdeaImages = CryptoIdeasModule.restoreImages
const restoreIdeasImages = (ideas: CONTRACT_INTERFACES.ITradeIdea[]) => {
	return Promise.all(ideas.map((idea) => restoreIdeaImages(idea)))
}

const getChronologicalIdeasFromStrategyChain =
	StrategyChainModule.chronologicalIdeasFromChain

const getActiveIdeasFromStrategyChain =
	StrategyChainModule.getActiveIdeasFromChain

const getExistingNftByStrategyRefAndTicker =
	ProvableIdeasModule.general.getExistingNftByStrategyRefAndTicker

const getPricingInfo = (tradeIdea: CONTRACT_INTERFACES.ITradeIdea) =>
	ProvableIdeasModule.general.getPricingInfo(
		tradeIdea.pricing,
		(tradeIdea.idea as ITradeIdeaIdea).asset.ticker,
		tradeIdea.tracker,
		tradeIdea.devSettings?.croupierUrl,
	)

const getVersion = () => {
	return version
}

const getContractDbVersion = () => {
	return contractDbVersion
}

const giveIdeaAccessTo = (
	nftId: number,
	addresses: string[],
	contract?: IContract,
) => ProvableIdeasModule.clientOnly.giveIdeaAccessTo(nftId, addresses, contract)

const getIdeaViewers = (nftId: number, contract?: IContract) =>
	ProvableIdeasModule.general.getIdeaViewers(nftId, contract)

const authorizeProvider = (
	provider: string,
	contract?: IContract,
): Promise<void> =>
	ProvableIdeasModule.clientOnly.authorizeProvider(provider, contract)

const revokeProvider = (
	provider: string,
	contract?: IContract,
): Promise<void> =>
	ProvableIdeasModule.clientOnly.revokeProvider(provider, contract)

const authorizeCheck = (
	provider: string,
	contract?: IContract,
): Promise<boolean> =>
	ProvableIdeasModule.clientOnly.authorizeCheck(provider, contract)

const providerCheck = (
	client: string,
	contract?: IContract,
): Promise<boolean> =>
	ProvableIdeasModule.providerOnly.providerCheck(client, contract)

const getKeysFromIdea = (
	tradeIdea: CONTRACT_INTERFACES.ITradeIdea,
): {
	strategyKey: string
	ideaKey?: number
	ideaStageKey?: number
	nftId?: number
	tradeIdea: CONTRACT_INTERFACES.ITradeIdea
} => {
	return {
		strategyKey: tradeIdea.strategy.reference,
		ideaKey: tradeIdea.content.ideaKey,
		ideaStageKey: tradeIdea.content.ideaStageKey,
		nftId: tradeIdea.nftId,
		tradeIdea,
	}
}

const isValidWalletAddress = (walletAddressList: string[]) => {
	let globalCheck = true
	const checkerResponse: {
		[key: string]: boolean
	} = {}

	for (const wallet of walletAddressList) {
		if (wallet) {
			checkerResponse[wallet] = ethers.utils.isAddress(wallet)
			if (!checkerResponse[wallet]) {
				globalCheck = false
			}
		}
	}

	return {
		globalCheck,
		checkerResponse,
	}
}

const testLitActionsAvailability = LitModule.testJS

const listNetworks = () => ACTIV_LIVE_CHAINS
// const listExchanges = () => PRICING_PROVIDERS

export const ActivV4Module = {
	settings,
	supportedChainNetworks,
	config,
	//
	getEstimatedCosts,
	// adminCreateIdea,
	createIdea,
	createPortfolioEntry,
	createPortfolio,
	createNormalizedTradeIdea,
	adjustIdea,
	closeIdea,

	providerCreateIdea,
	providerCloseIdea,
	providerAdjustIdea,
	providerCreateFiatMintIdea,

	createIdeaFromFiatMint,
	createNormalizedTradeIdeaFromFiatMint,
	adjustIdeaFromFiatMint,
	closeIdeaFromFiatMint,

	// adminCreateClientTokens,
	giveIdeaAccessTo,
	getPricingInfo,
	getIdeaViewers,
	// crud

	// contract
	// listAllStrategies,

	// creator of ideas
	listStrategiesByCreator,
	listStrategyIdeasByCreatorAndReference,
	listStrategyIdeasStagesByCreatorAndReference,
	//
	getIdeaNftIdByKeys,
	getIdeaMetadataByKeys,
	getIdeaByKeys,
	getIdeaByNftId,

	// owner of token to ideas
	// getOwnedByIdeas,
	// getOwnedByNfts,
	// getCreatedByIdeas,
	// getCreatedByNfts,
	// getMyIdeasByFilter,
	getExistingNftByStrategyRefAndTicker,

	getCreatorOfNftIdea,

	restoredIdeasWithPagination,
	restoreIdeaImages,
	restoreIdeasImages,

	getAllIdeasUserCanSee,
	getAllMyIdeas,
	getMyIdeas,
	// getAllPublicIdeas,
	getMetadataByBlockId,
	getKeysFromIdea,

	testPricingAsset,

	// adminListStrategies,
	getStrategyChain,
	getValidatedStrategyChain,
	getStrategyMetadata,
	getChronologicalIdeasFromStrategyChain,
	getActiveIdeasFromStrategyChain,
	getCurrentStrategyTickers,
	// adminGetStrategyChain,
	// getStrategyIdeas,

	authorizeProvider,
	revokeProvider,
	authorizeCheck,
	providerCheck,

	// contract setup
	listContractChains,
	listContractsForChain,
	selectChainContract,
	getBlockchainContract,
	getGateContract,
	testLitActionsAvailability,

	isValidWalletAddress,

	listNetworks,
	// listExchanges,

	// canonical
	readEvents,
	updateCurrentContractDb,
	serveContractsDb,
	// listCreatorAndStrategyReferences,
	listStrategyReferences,
	getStrategyIdeasCanonical,
	listStrategyReferencesCanonical,
	listStrategiesDetailsCanonical,
	listAllIdeasCanonical, // TODO: this is not All, but all for creator

	...MigrationV3TemporaryModule,

	getVersion,
	getContractDbVersion,
	query: {
		...QueryViewsModule,
	},
}