@merkl/api 0.10.393 → 0.10.396

package/dist/database/api/.generated/drizzle/schema.ts

@@ -0,0 +1,906 @@
+import { relations } from 'drizzle-orm'
+import { bigint, boolean, doublePrecision, foreignKey, integer, jsonb, pgEnum, pgTable, serial, text, timestamp, uniqueIndex } from 'drizzle-orm/pg-core'
+
+export const RunStatus = pgEnum('RunStatus', ['PROCESSING', 'SUCCESS', 'FAILED', 'SKIPPED'])
+
+export const CampaignType = pgEnum('CampaignType', ['INVALID', 'ERC20', 'CLAMM', 'ERC20_SNAPSHOT', 'JSON_AIRDROP', 'SILO', 'RADIANT', 'MORPHO', 'DOLOMITE', 'BADGER', 'COMPOUND', 'AJNA', 'EULER', 'UNISWAP_V4', 'ION', 'EIGENLAYER', 'ERC20TRANSFERS', 'ERC20LOGPROCESSOR', 'ERC20REBASELOGPROCESSOR', 'VEST', 'ERC20_FIX_APR', 'HYPERDRIVELOGPROCESSOR', 'HYPERDRIVELOGFIXPROCESSOR'])
+
+export const OpportunityAction = pgEnum('OpportunityAction', ['POOL', 'HOLD', 'DROP', 'LEND', 'BORROW', 'LONG', 'SHORT', 'INVALID'])
+
+export const Status = pgEnum('Status', ['NONE', 'PAST', 'LIVE', 'SOON'])
+
+export const ExplorerType = pgEnum('ExplorerType', ['ETHERSCAN', 'BLOCKSCOUT'])
+
+export const AprType = pgEnum('AprType', ['CAMPAIGN', 'TOKEN', 'PROTOCOL'])
+
+export const TvlType = pgEnum('TvlType', ['TOKEN', 'PROTOCOL'])
+
+export const PriceSourceMethod = pgEnum('PriceSourceMethod', ['COINGECKO', 'CONSTANT', 'EQUAL_TO', 'ERC4626', 'DEXSCREENER', 'INDEXCOOP', 'DEFILLAMA'])
+
+export const Campaign = pgTable('Campaign', {
+	id: text('id').notNull().primaryKey(),
+	computeChainId: integer('computeChainId').notNull(),
+	distributionChainId: integer('distributionChainId').notNull(),
+	campaignId: text('campaignId').notNull(),
+	type: CampaignType('type').notNull(),
+	subType: integer('subType'),
+	rewardTokenId: text('rewardTokenId').notNull(),
+	amount: text('amount').notNull(),
+	opportunityId: text('opportunityId').notNull(),
+	startTimestamp: bigint('startTimestamp', { mode: 'bigint' }).notNull(),
+	endTimestamp: bigint('endTimestamp', { mode: 'bigint' }).notNull(),
+	params: jsonb('params').notNull(),
+	creatorAddress: text('creatorAddress').notNull()
+}, (Campaign) => ({
+	'Campaign_ComputeChain_fkey': foreignKey({
+		name: 'Campaign_ComputeChain_fkey',
+		columns: [Campaign.computeChainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Campaign_DistributionChain_fkey': foreignKey({
+		name: 'Campaign_DistributionChain_fkey',
+		columns: [Campaign.distributionChainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Campaign_RewardToken_fkey': foreignKey({
+		name: 'Campaign_RewardToken_fkey',
+		columns: [Campaign.rewardTokenId],
+		foreignColumns: [Token.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Campaign_Opportunity_fkey': foreignKey({
+		name: 'Campaign_Opportunity_fkey',
+		columns: [Campaign.opportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Campaign_Creator_fkey': foreignKey({
+		name: 'Campaign_Creator_fkey',
+		columns: [Campaign.creatorAddress],
+		foreignColumns: [User.address]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Campaign_distributionChainId_campaignId_unique_idx': uniqueIndex('Campaign_distributionChainId_campaignId_key')
+		.on(Campaign.distributionChainId, Campaign.campaignId)
+}));
+
+export const CampaignStatus = pgTable('CampaignStatus', {
+	campaignId: text('campaignId').notNull().primaryKey(),
+	computedUntil: bigint('computedUntil', { mode: 'bigint' }).notNull().default("0"),
+	processingStarted: bigint('processingStarted', { mode: 'bigint' }).notNull().default("0"),
+	status: RunStatus('status').notNull().default("SUCCESS"),
+	error: text('error').notNull(),
+	details: jsonb('details').notNull().default("{}")
+}, (CampaignStatus) => ({
+	'CampaignStatus_Campaign_fkey': foreignKey({
+		name: 'CampaignStatus_Campaign_fkey',
+		columns: [CampaignStatus.campaignId],
+		foreignColumns: [Campaign.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const CampaignComputedValue = pgTable('CampaignComputedValue', {
+	campaignId: text('campaignId').notNull().primaryKey(),
+	averageBoost: doublePrecision('averageBoost'),
+	totalDistributedInUSD: doublePrecision('totalDistributedInUSD'),
+	forfeitingBoost: doublePrecision('forfeitingBoost')
+}, (CampaignComputedValue) => ({
+	'CampaignComputedValue_Campaign_fkey': foreignKey({
+		name: 'CampaignComputedValue_Campaign_fkey',
+		columns: [CampaignComputedValue.campaignId],
+		foreignColumns: [Campaign.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const UserComputedValue = pgTable('UserComputedValue', {
+	id: serial('id').notNull().primaryKey(),
+	campaignId: text('campaignId').notNull(),
+	address: text('address').notNull(),
+	reason: text('reason').notNull(),
+	boost: doublePrecision('boost')
+}, (UserComputedValue) => ({
+	'UserComputedValue_Campaign_fkey': foreignKey({
+		name: 'UserComputedValue_Campaign_fkey',
+		columns: [UserComputedValue.campaignId],
+		foreignColumns: [Campaign.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'UserComputedValue_User_fkey': foreignKey({
+		name: 'UserComputedValue_User_fkey',
+		columns: [UserComputedValue.address],
+		foreignColumns: [User.address]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'UserComputedValue_campaignId_address_reason_unique_idx': uniqueIndex('UserComputedValue_campaignId_address_reason_key')
+		.on(UserComputedValue.campaignId, UserComputedValue.address, UserComputedValue.reason)
+}));
+
+export const Chain = pgTable('Chain', {
+	id: integer('id').notNull().primaryKey(),
+	name: text('name').notNull(),
+	icon: text('icon').notNull()
+});
+
+export const Explorer = pgTable('Explorer', {
+	id: text('id').notNull().primaryKey(),
+	type: ExplorerType('type').notNull(),
+	url: text('url').notNull(),
+	chainId: integer('chainId').notNull()
+}, (Explorer) => ({
+	'Explorer_Chain_fkey': foreignKey({
+		name: 'Explorer_Chain_fkey',
+		columns: [Explorer.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Explorer_type_chainId_unique_idx': uniqueIndex('Explorer_type_chainId_key')
+		.on(Explorer.type, Explorer.chainId)
+}));
+
+export const Opportunity = pgTable('Opportunity', {
+	id: text('id').notNull().primaryKey(),
+	chainId: integer('chainId').notNull(),
+	type: CampaignType('type').notNull(),
+	identifier: text('identifier').notNull(),
+	name: text('name').notNull(),
+	depositUrl: text('depositUrl'),
+	status: Status('status').notNull(),
+	action: OpportunityAction('action').notNull(),
+	mainProtocolId: text('mainProtocolId'),
+	tvl: doublePrecision('tvl').notNull(),
+	apr: doublePrecision('apr').notNull(),
+	dailyRewards: doublePrecision('dailyRewards').notNull(),
+	tags: text('tags').array().notNull().default([])
+}, (Opportunity) => ({
+	'Opportunity_Chain_fkey': foreignKey({
+		name: 'Opportunity_Chain_fkey',
+		columns: [Opportunity.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Opportunity_MainProtocol_fkey': foreignKey({
+		name: 'Opportunity_MainProtocol_fkey',
+		columns: [Opportunity.mainProtocolId],
+		foreignColumns: [Protocol.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Opportunity_chainId_type_identifier_unique_idx': uniqueIndex('Opportunity_chainId_type_identifier_key')
+		.on(Opportunity.chainId, Opportunity.type, Opportunity.identifier)
+}));
+
+export const Protocol = pgTable('Protocol', {
+	id: text('id').notNull().primaryKey(),
+	tags: text('tags').array().notNull().default([]),
+	name: text('name').notNull(),
+	description: text('description').notNull(),
+	url: text('url').notNull(),
+	icon: text('icon').notNull()
+});
+
+export const Token = pgTable('Token', {
+	id: text('id').notNull().primaryKey(),
+	name: text('name'),
+	chainId: integer('chainId').notNull(),
+	address: text('address').notNull(),
+	decimals: integer('decimals').notNull(),
+	symbol: text('symbol').notNull(),
+	displaySymbol: text('displaySymbol').notNull(),
+	icon: text('icon').notNull(),
+	verified: boolean('verified').notNull(),
+	isTest: boolean('isTest').notNull(),
+	price: doublePrecision('price')
+}, (Token) => ({
+	'Token_Chain_fkey': foreignKey({
+		name: 'Token_Chain_fkey',
+		columns: [Token.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Token_chainId_address_unique_idx': uniqueIndex('Token_chainId_address_key')
+		.on(Token.chainId, Token.address)
+}));
+
+export const AprRecord = pgTable('AprRecord', {
+	id: text('id').notNull().primaryKey(),
+	timestamp: bigint('timestamp', { mode: 'bigint' }).notNull(),
+	cumulated: doublePrecision('cumulated').notNull(),
+	opportunityId: text('opportunityId').notNull()
+}, (AprRecord) => ({
+	'AprRecord_Opportunity_fkey': foreignKey({
+		name: 'AprRecord_Opportunity_fkey',
+		columns: [AprRecord.opportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'AprRecord_opportunityId_timestamp_unique_idx': uniqueIndex('AprRecord_opportunityId_timestamp_key')
+		.on(AprRecord.opportunityId, AprRecord.timestamp)
+}));
+
+export const AprBreakdown = pgTable('AprBreakdown', {
+	id: serial('id').notNull().primaryKey(),
+	identifier: text('identifier').notNull(),
+	type: AprType('type').notNull(),
+	value: doublePrecision('value').notNull(),
+	aprRecordId: text('aprRecordId').notNull()
+}, (AprBreakdown) => ({
+	'AprBreakdown_AprRecord_fkey': foreignKey({
+		name: 'AprBreakdown_AprRecord_fkey',
+		columns: [AprBreakdown.aprRecordId],
+		foreignColumns: [AprRecord.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const TVLRecord = pgTable('TVLRecord', {
+	id: text('id').notNull().primaryKey(),
+	timestamp: bigint('timestamp', { mode: 'bigint' }).notNull(),
+	total: doublePrecision('total').notNull(),
+	opportunityId: text('opportunityId').notNull()
+}, (TVLRecord) => ({
+	'TVLRecord_Opportunity_fkey': foreignKey({
+		name: 'TVLRecord_Opportunity_fkey',
+		columns: [TVLRecord.opportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'TVLRecord_opportunityId_timestamp_unique_idx': uniqueIndex('TVLRecord_opportunityId_timestamp_key')
+		.on(TVLRecord.opportunityId, TVLRecord.timestamp)
+}));
+
+export const TVLBreakdown = pgTable('TVLBreakdown', {
+	id: serial('id').notNull().primaryKey(),
+	identifier: text('identifier').notNull(),
+	type: TvlType('type').notNull(),
+	value: doublePrecision('value').notNull(),
+	tvlRecordId: text('tvlRecordId').notNull()
+}, (TVLBreakdown) => ({
+	'TVLBreakdown_TvlRecord_fkey': foreignKey({
+		name: 'TVLBreakdown_TvlRecord_fkey',
+		columns: [TVLBreakdown.tvlRecordId],
+		foreignColumns: [TVLRecord.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const DailyRewardsRecord = pgTable('DailyRewardsRecord', {
+	id: text('id').notNull().primaryKey(),
+	timestamp: bigint('timestamp', { mode: 'bigint' }).notNull(),
+	total: doublePrecision('total').notNull(),
+	opportunityId: text('opportunityId').notNull()
+}, (DailyRewardsRecord) => ({
+	'DailyRewardsRecord_Opportunity_fkey': foreignKey({
+		name: 'DailyRewardsRecord_Opportunity_fkey',
+		columns: [DailyRewardsRecord.opportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'DailyRewardsRecord_opportunityId_timestamp_unique_idx': uniqueIndex('DailyRewardsRecord_opportunityId_timestamp_key')
+		.on(DailyRewardsRecord.opportunityId, DailyRewardsRecord.timestamp)
+}));
+
+export const DailyRewardsBreakdown = pgTable('DailyRewardsBreakdown', {
+	id: serial('id').notNull().primaryKey(),
+	value: doublePrecision('value').notNull(),
+	campaignId: text('campaignId').notNull(),
+	dailyRewardsRecordId: text('dailyRewardsRecordId').notNull()
+}, (DailyRewardsBreakdown) => ({
+	'DailyRewardsBreakdown_Campaign_fkey': foreignKey({
+		name: 'DailyRewardsBreakdown_Campaign_fkey',
+		columns: [DailyRewardsBreakdown.campaignId],
+		foreignColumns: [Campaign.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'DailyRewardsBreakdown_DailyRewardsRecord_fkey': foreignKey({
+		name: 'DailyRewardsBreakdown_DailyRewardsRecord_fkey',
+		columns: [DailyRewardsBreakdown.dailyRewardsRecordId],
+		foreignColumns: [DailyRewardsRecord.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const User = pgTable('User', {
+	address: text('address').notNull().primaryKey(),
+	tags: text('tags').array().notNull(),
+	creatorId: text('creatorId')
+}, (User) => ({
+	'User_Creator_fkey': foreignKey({
+		name: 'User_Creator_fkey',
+		columns: [User.creatorId],
+		foreignColumns: [Creator.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const Creator = pgTable('Creator', {
+	id: text('id').notNull().primaryKey(),
+	icon: text('icon'),
+	name: text('name').notNull()
+});
+
+export const Reward = pgTable('Reward', {
+	id: text('id').notNull().primaryKey(),
+	root: text('root').notNull(),
+	recipient: text('recipient').notNull(),
+	rewardTokenId: text('rewardTokenId').notNull(),
+	amount: text('amount').notNull().default("0"),
+	claimed: text('claimed').notNull().default("0"),
+	pending: text('pending').notNull().default("0"),
+	proofs: text('proofs').array().notNull()
+}, (Reward) => ({
+	'Reward_MerklRoot_fkey': foreignKey({
+		name: 'Reward_MerklRoot_fkey',
+		columns: [Reward.root],
+		foreignColumns: [MerklRoot.root]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Reward_User_fkey': foreignKey({
+		name: 'Reward_User_fkey',
+		columns: [Reward.recipient],
+		foreignColumns: [User.address]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Reward_RewardToken_fkey': foreignKey({
+		name: 'Reward_RewardToken_fkey',
+		columns: [Reward.rewardTokenId],
+		foreignColumns: [Token.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Reward_root_recipient_rewardTokenId_unique_idx': uniqueIndex('Reward_root_recipient_rewardTokenId_key')
+		.on(Reward.root, Reward.recipient, Reward.rewardTokenId)
+}));
+
+export const RewardBreakdown = pgTable('RewardBreakdown', {
+	id: serial('id').notNull().primaryKey(),
+	protocolId: text('protocolId'),
+	reason: text('reason').notNull(),
+	amount: text('amount').notNull(),
+	claimed: text('claimed').notNull(),
+	pending: text('pending').notNull(),
+	rewardId: text('rewardId').notNull(),
+	campaignId: text('campaignId').notNull()
+}, (RewardBreakdown) => ({
+	'RewardBreakdown_Protocol_fkey': foreignKey({
+		name: 'RewardBreakdown_Protocol_fkey',
+		columns: [RewardBreakdown.protocolId],
+		foreignColumns: [Protocol.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'RewardBreakdown_Reward_fkey': foreignKey({
+		name: 'RewardBreakdown_Reward_fkey',
+		columns: [RewardBreakdown.rewardId],
+		foreignColumns: [Reward.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'RewardBreakdown_Campaign_fkey': foreignKey({
+		name: 'RewardBreakdown_Campaign_fkey',
+		columns: [RewardBreakdown.campaignId],
+		foreignColumns: [Campaign.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'RewardBreakdown_rewardId_campaignId_reason_unique_idx': uniqueIndex('RewardBreakdown_rewardId_campaignId_reason_key')
+		.on(RewardBreakdown.rewardId, RewardBreakdown.campaignId, RewardBreakdown.reason)
+}));
+
+export const MerklRoot = pgTable('MerklRoot', {
+	root: text('root').notNull().primaryKey(),
+	chainId: integer('chainId').notNull(),
+	epoch: integer('epoch').notNull(),
+	timestamp: bigint('timestamp', { mode: 'bigint' }).notNull()
+}, (MerklRoot) => ({
+	'MerklRoot_Chain_fkey': foreignKey({
+		name: 'MerklRoot_Chain_fkey',
+		columns: [MerklRoot.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const PriceSource = pgTable('PriceSource', {
+	id: serial('id').notNull().primaryKey(),
+	symbol: text('symbol').notNull().unique(),
+	method: PriceSourceMethod('method').notNull(),
+	args: jsonb('args')
+});
+
+export const Blacklist = pgTable('Blacklist', {
+	id: text('id').notNull().primaryKey(),
+	chainId: integer('chainId').notNull(),
+	poolAddress: text('poolAddress').notNull(),
+	userAddress: text('userAddress').notNull(),
+	arrestTimestamp: bigint('arrestTimestamp', { mode: 'bigint' }).notNull(),
+	arrestDetails: jsonb('arrestDetails').notNull()
+}, (Blacklist) => ({
+	'Blacklist_Chain_fkey': foreignKey({
+		name: 'Blacklist_Chain_fkey',
+		columns: [Blacklist.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Blacklist_User_fkey': foreignKey({
+		name: 'Blacklist_User_fkey',
+		columns: [Blacklist.userAddress],
+		foreignColumns: [User.address]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Blacklist_chainId_userAddress_poolAddress_unique_idx': uniqueIndex('Blacklist_chainId_userAddress_poolAddress_key')
+		.on(Blacklist.chainId, Blacklist.userAddress, Blacklist.poolAddress)
+}));
+
+export const Dump = pgTable('Dump', {
+	id: text('id').notNull().primaryKey(),
+	chainId: integer('chainId').notNull(),
+	fromTokenId: text('fromTokenId').notNull(),
+	toTokenId: text('toTokenId').notNull(),
+	multisig: text('multisig').notNull(),
+	recipient: text('recipient').notNull(),
+	amountIn: text('amountIn').notNull().default("0"),
+	amountOut: text('amountOut').notNull().default("0"),
+	datetime: timestamp('datetime', { precision: 3 }).notNull(),
+	timestamp: integer('timestamp').notNull()
+}, (Dump) => ({
+	'Dump_Chain_fkey': foreignKey({
+		name: 'Dump_Chain_fkey',
+		columns: [Dump.chainId],
+		foreignColumns: [Chain.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Dump_FromToken_fkey': foreignKey({
+		name: 'Dump_FromToken_fkey',
+		columns: [Dump.fromTokenId],
+		foreignColumns: [Token.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Dump_ToToken_fkey': foreignKey({
+		name: 'Dump_ToToken_fkey',
+		columns: [Dump.toTokenId],
+		foreignColumns: [Token.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'Dump_chainId_fromTokenId_toTokenId_timestamp_unique_idx': uniqueIndex('Dump_chainId_fromTokenId_toTokenId_timestamp_key')
+		.on(Dump.chainId, Dump.fromTokenId, Dump.toTokenId, Dump.timestamp)
+}));
+
+export const OpportunityToToken = pgTable('_OpportunityToToken', {
+	TokenId: text('A').notNull(),
+	OpportunityId: text('B').notNull()
+}, (OpportunityToToken) => ({
+	'_OpportunityToToken_Token_fkey': foreignKey({
+		name: '_OpportunityToToken_Token_fkey',
+		columns: [OpportunityToToken.TokenId],
+		foreignColumns: [Token.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'_OpportunityToToken_Opportunity_fkey': foreignKey({
+		name: '_OpportunityToToken_Opportunity_fkey',
+		columns: [OpportunityToToken.OpportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const OpportunityToProtocol = pgTable('_OpportunityToProtocol', {
+	ProtocolId: text('A').notNull(),
+	OpportunityId: text('B').notNull()
+}, (OpportunityToProtocol) => ({
+	'_OpportunityToProtocol_Protocol_fkey': foreignKey({
+		name: '_OpportunityToProtocol_Protocol_fkey',
+		columns: [OpportunityToProtocol.ProtocolId],
+		foreignColumns: [Protocol.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade'),
+	'_OpportunityToProtocol_Opportunity_fkey': foreignKey({
+		name: '_OpportunityToProtocol_Opportunity_fkey',
+		columns: [OpportunityToProtocol.OpportunityId],
+		foreignColumns: [Opportunity.id]
+	})
+		.onDelete('cascade')
+		.onUpdate('cascade')
+}));
+
+export const CampaignRelations = relations(Campaign, ({ one, many }) => ({
+	ComputeChain: one(Chain, {
+		relationName: 'compute',
+		fields: [Campaign.computeChainId],
+		references: [Chain.id]
+	}),
+	DistributionChain: one(Chain, {
+		relationName: 'distribution',
+		fields: [Campaign.distributionChainId],
+		references: [Chain.id]
+	}),
+	RewardToken: one(Token, {
+		relationName: 'CampaignToToken',
+		fields: [Campaign.rewardTokenId],
+		references: [Token.id]
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'CampaignToOpportunity',
+		fields: [Campaign.opportunityId],
+		references: [Opportunity.id]
+	}),
+	RewardBreakdown: many(RewardBreakdown, {
+		relationName: 'CampaignToRewardBreakdown'
+	}),
+	DailyRewardsBreakdown: many(DailyRewardsBreakdown, {
+		relationName: 'CampaignToDailyRewardsBreakdown'
+	}),
+	Creator: one(User, {
+		relationName: 'CampaignToUser',
+		fields: [Campaign.creatorAddress],
+		references: [User.address]
+	}),
+	CampaignStatus: many(CampaignStatus, {
+		relationName: 'CampaignToCampaignStatus'
+	}),
+	CampaignEngineValues: many(CampaignComputedValue, {
+		relationName: 'CampaignToCampaignComputedValue'
+	}),
+	UserComputedValue: many(UserComputedValue, {
+		relationName: 'CampaignToUserComputedValue'
+	})
+}));
+
+export const CampaignStatusRelations = relations(CampaignStatus, ({ one }) => ({
+	Campaign: one(Campaign, {
+		relationName: 'CampaignToCampaignStatus',
+		fields: [CampaignStatus.campaignId],
+		references: [Campaign.id]
+	})
+}));
+
+export const CampaignComputedValueRelations = relations(CampaignComputedValue, ({ one }) => ({
+	Campaign: one(Campaign, {
+		relationName: 'CampaignToCampaignComputedValue',
+		fields: [CampaignComputedValue.campaignId],
+		references: [Campaign.id]
+	})
+}));
+
+export const UserComputedValueRelations = relations(UserComputedValue, ({ one }) => ({
+	Campaign: one(Campaign, {
+		relationName: 'CampaignToUserComputedValue',
+		fields: [UserComputedValue.campaignId],
+		references: [Campaign.id]
+	}),
+	User: one(User, {
+		relationName: 'UserToUserComputedValue',
+		fields: [UserComputedValue.address],
+		references: [User.address]
+	})
+}));
+
+export const ChainRelations = relations(Chain, ({ many }) => ({
+	Explorer: many(Explorer, {
+		relationName: 'ChainToExplorer'
+	}),
+	Campaigns: many(Campaign, {
+		relationName: 'compute'
+	}),
+	Distribution: many(Campaign, {
+		relationName: 'distribution'
+	}),
+	Token: many(Token, {
+		relationName: 'ChainToToken'
+	}),
+	Opportunity: many(Opportunity, {
+		relationName: 'ChainToOpportunity'
+	}),
+	MerklRoot: many(MerklRoot, {
+		relationName: 'ChainToMerklRoot'
+	}),
+	Blacklist: many(Blacklist, {
+		relationName: 'BlacklistToChain'
+	}),
+	Dump: many(Dump, {
+		relationName: 'ChainToDump'
+	})
+}));
+
+export const ExplorerRelations = relations(Explorer, ({ one }) => ({
+	Chain: one(Chain, {
+		relationName: 'ChainToExplorer',
+		fields: [Explorer.chainId],
+		references: [Chain.id]
+	})
+}));
+
+export const OpportunityRelations = relations(Opportunity, ({ one, many }) => ({
+	Chain: one(Chain, {
+		relationName: 'ChainToOpportunity',
+		fields: [Opportunity.chainId],
+		references: [Chain.id]
+	}),
+	Tokens: many(OpportunityToToken, {
+		relationName: 'OpportunityToOpportunityToToken'
+	}),
+	Campaigns: many(Campaign, {
+		relationName: 'CampaignToOpportunity'
+	}),
+	Protocols: many(OpportunityToProtocol, {
+		relationName: 'OpportunityToOpportunityToProtocol'
+	}),
+	MainProtocol: one(Protocol, {
+		relationName: 'main',
+		fields: [Opportunity.mainProtocolId],
+		references: [Protocol.id]
+	}),
+	TvlRecords: many(TVLRecord, {
+		relationName: 'OpportunityToTVLRecord'
+	}),
+	AprRecords: many(AprRecord, {
+		relationName: 'AprRecordToOpportunity'
+	}),
+	DailyRewardsRecords: many(DailyRewardsRecord, {
+		relationName: 'DailyRewardsRecordToOpportunity'
+	})
+}));
+
+export const ProtocolRelations = relations(Protocol, ({ many }) => ({
+	MainOpportunities: many(Opportunity, {
+		relationName: 'main'
+	}),
+	Opportunities: many(OpportunityToProtocol, {
+		relationName: 'ProtocolToOpportunityToProtocol'
+	}),
+	RewardBreakdown: many(RewardBreakdown, {
+		relationName: 'ProtocolToRewardBreakdown'
+	})
+}));
+
+export const TokenRelations = relations(Token, ({ one, many }) => ({
+	Chain: one(Chain, {
+		relationName: 'ChainToToken',
+		fields: [Token.chainId],
+		references: [Chain.id]
+	}),
+	Opportunity: many(OpportunityToToken, {
+		relationName: 'TokenToOpportunityToToken'
+	}),
+	Campaigns: many(Campaign, {
+		relationName: 'CampaignToToken'
+	}),
+	Reward: many(Reward, {
+		relationName: 'RewardToToken'
+	}),
+	DumpTo: many(Dump, {
+		relationName: 'to'
+	}),
+	DumpFrom: many(Dump, {
+		relationName: 'from'
+	})
+}));
+
+export const AprRecordRelations = relations(AprRecord, ({ many, one }) => ({
+	AprBreakdown: many(AprBreakdown, {
+		relationName: 'AprBreakdownToAprRecord'
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'AprRecordToOpportunity',
+		fields: [AprRecord.opportunityId],
+		references: [Opportunity.id]
+	})
+}));
+
+export const AprBreakdownRelations = relations(AprBreakdown, ({ one }) => ({
+	AprRecord: one(AprRecord, {
+		relationName: 'AprBreakdownToAprRecord',
+		fields: [AprBreakdown.aprRecordId],
+		references: [AprRecord.id]
+	})
+}));
+
+export const TVLRecordRelations = relations(TVLRecord, ({ many, one }) => ({
+	TvlBreakdown: many(TVLBreakdown, {
+		relationName: 'TVLBreakdownToTVLRecord'
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'OpportunityToTVLRecord',
+		fields: [TVLRecord.opportunityId],
+		references: [Opportunity.id]
+	})
+}));
+
+export const TVLBreakdownRelations = relations(TVLBreakdown, ({ one }) => ({
+	TvlRecord: one(TVLRecord, {
+		relationName: 'TVLBreakdownToTVLRecord',
+		fields: [TVLBreakdown.tvlRecordId],
+		references: [TVLRecord.id]
+	})
+}));
+
+export const DailyRewardsRecordRelations = relations(DailyRewardsRecord, ({ many, one }) => ({
+	DailyRewardsBreakdown: many(DailyRewardsBreakdown, {
+		relationName: 'DailyRewardsBreakdownToDailyRewardsRecord'
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'DailyRewardsRecordToOpportunity',
+		fields: [DailyRewardsRecord.opportunityId],
+		references: [Opportunity.id]
+	})
+}));
+
+export const DailyRewardsBreakdownRelations = relations(DailyRewardsBreakdown, ({ one }) => ({
+	Campaign: one(Campaign, {
+		relationName: 'CampaignToDailyRewardsBreakdown',
+		fields: [DailyRewardsBreakdown.campaignId],
+		references: [Campaign.id]
+	}),
+	DailyRewardsRecord: one(DailyRewardsRecord, {
+		relationName: 'DailyRewardsBreakdownToDailyRewardsRecord',
+		fields: [DailyRewardsBreakdown.dailyRewardsRecordId],
+		references: [DailyRewardsRecord.id]
+	})
+}));
+
+export const UserRelations = relations(User, ({ many, one }) => ({
+	Rewards: many(Reward, {
+		relationName: 'RewardToUser'
+	}),
+	Blacklist: many(Blacklist, {
+		relationName: 'BlacklistToUser'
+	}),
+	CampaignsCreated: many(Campaign, {
+		relationName: 'CampaignToUser'
+	}),
+	UserComputedValue: many(UserComputedValue, {
+		relationName: 'UserToUserComputedValue'
+	}),
+	Creator: one(Creator, {
+		relationName: 'CreatorToUser',
+		fields: [User.creatorId],
+		references: [Creator.id]
+	})
+}));
+
+export const CreatorRelations = relations(Creator, ({ many }) => ({
+	Users: many(User, {
+		relationName: 'CreatorToUser'
+	})
+}));
+
+export const RewardRelations = relations(Reward, ({ one, many }) => ({
+	MerklRoot: one(MerklRoot, {
+		relationName: 'MerklRootToReward',
+		fields: [Reward.root],
+		references: [MerklRoot.root]
+	}),
+	User: one(User, {
+		relationName: 'RewardToUser',
+		fields: [Reward.recipient],
+		references: [User.address]
+	}),
+	RewardToken: one(Token, {
+		relationName: 'RewardToToken',
+		fields: [Reward.rewardTokenId],
+		references: [Token.id]
+	}),
+	Breakdown: many(RewardBreakdown, {
+		relationName: 'RewardToRewardBreakdown'
+	})
+}));
+
+export const RewardBreakdownRelations = relations(RewardBreakdown, ({ one }) => ({
+	Protocol: one(Protocol, {
+		relationName: 'ProtocolToRewardBreakdown',
+		fields: [RewardBreakdown.protocolId],
+		references: [Protocol.id]
+	}),
+	Reward: one(Reward, {
+		relationName: 'RewardToRewardBreakdown',
+		fields: [RewardBreakdown.rewardId],
+		references: [Reward.id]
+	}),
+	Campaign: one(Campaign, {
+		relationName: 'CampaignToRewardBreakdown',
+		fields: [RewardBreakdown.campaignId],
+		references: [Campaign.id]
+	})
+}));
+
+export const MerklRootRelations = relations(MerklRoot, ({ one, many }) => ({
+	Chain: one(Chain, {
+		relationName: 'ChainToMerklRoot',
+		fields: [MerklRoot.chainId],
+		references: [Chain.id]
+	}),
+	Rewards: many(Reward, {
+		relationName: 'MerklRootToReward'
+	})
+}));
+
+export const BlacklistRelations = relations(Blacklist, ({ one }) => ({
+	Chain: one(Chain, {
+		relationName: 'BlacklistToChain',
+		fields: [Blacklist.chainId],
+		references: [Chain.id]
+	}),
+	User: one(User, {
+		relationName: 'BlacklistToUser',
+		fields: [Blacklist.userAddress],
+		references: [User.address]
+	})
+}));
+
+export const DumpRelations = relations(Dump, ({ one }) => ({
+	Chain: one(Chain, {
+		relationName: 'ChainToDump',
+		fields: [Dump.chainId],
+		references: [Chain.id]
+	}),
+	FromToken: one(Token, {
+		relationName: 'from',
+		fields: [Dump.fromTokenId],
+		references: [Token.id]
+	}),
+	ToToken: one(Token, {
+		relationName: 'to',
+		fields: [Dump.toTokenId],
+		references: [Token.id]
+	})
+}));
+
+export const OpportunityToTokenRelations = relations(OpportunityToToken, ({ one }) => ({
+	Token: one(Token, {
+		relationName: 'TokenToOpportunityToToken',
+		fields: [OpportunityToToken.TokenId],
+		references: [Token.id]
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'OpportunityToOpportunityToToken',
+		fields: [OpportunityToToken.OpportunityId],
+		references: [Opportunity.id]
+	})
+}));
+
+export const OpportunityToProtocolRelations = relations(OpportunityToProtocol, ({ one }) => ({
+	Protocol: one(Protocol, {
+		relationName: 'ProtocolToOpportunityToProtocol',
+		fields: [OpportunityToProtocol.ProtocolId],
+		references: [Protocol.id]
+	}),
+	Opportunity: one(Opportunity, {
+		relationName: 'OpportunityToOpportunityToProtocol',
+		fields: [OpportunityToProtocol.OpportunityId],
+		references: [Opportunity.id]
+	})
+}));