migrate type specific dynamic data to json column

balancer · Feb 6, 2024 · 8b9ce39 · 8b9ce39
1 parent e1f0909
commit 8b9ce39
Show file tree

Hide file tree

Showing 12 changed files with 69 additions and 168 deletions.
diff --git a/modules/pool/lib/pool-gql-loader.service.ts b/modules/pool/lib/pool-gql-loader.service.ts
@@ -48,7 +48,7 @@ import { BalancerChainIds, BeethovenChainIds, chainIdToChain, chainToIdMap } fro
 import { GithubContentService } from '../../content/github-content.service';
 import { SanityContentService } from '../../content/sanity-content.service';
 import { FeaturedPool } from '../../content/content-types';
-import { ElementData, FxData, GyroData, LinearData } from '../subgraph-mapper';
+import { ElementData, FxData, GyroData, LinearData, StableData } from '../subgraph-mapper';
 
 export class PoolGqlLoaderService {
     public async getPool(id: string, chain: Chain, userAddress?: string): Promise<GqlPoolUnion> {
@@ -478,24 +478,24 @@ export class PoolGqlLoaderService {
                 return {
                     __typename: 'GqlPoolStable',
                     ...poolWithoutStaticTypeData,
+                    ...(staticTypeData as StableData),
                     ...mappedData,
-                    amp: pool.stableDynamicData?.amp || '0',
                     tokens: mappedData.tokens as GqlPoolToken[],
                 };
             case 'META_STABLE':
                 return {
                     __typename: 'GqlPoolMetaStable',
                     ...poolWithoutStaticTypeData,
+                    ...(staticTypeData as StableData),
                     ...mappedData,
-                    amp: pool.stableDynamicData?.amp || '0',
                     tokens: mappedData.tokens as GqlPoolToken[],
                 };
             case 'COMPOSABLE_STABLE':
                 return {
                     __typename: 'GqlPoolComposableStable',
                     ...poolWithoutStaticTypeData,
+                    ...(staticTypeData as StableData),
                     ...mappedData,
-                    amp: pool.stableDynamicData?.amp || '0',
                     bptPriceRate: bpt?.dynamicData?.priceRate || '1.0',
                 };
             case 'LINEAR':
@@ -505,8 +505,6 @@ export class PoolGqlLoaderService {
                     ...(staticTypeData as LinearData),
                     ...mappedData,
                     tokens: mappedData.tokens as GqlPoolToken[],
-                    lowerTarget: pool.linearDynamicData?.lowerTarget || '0',
-                    upperTarget: pool.linearDynamicData?.upperTarget || '0',
                     bptPriceRate: bpt?.dynamicData?.priceRate || '1.0',
                 };
             case 'ELEMENT':
@@ -1134,7 +1132,6 @@ export class PoolGqlLoaderService {
             __typename: 'GqlPoolLinearNested',
             ...pool,
             ...(pool.staticTypeData as LinearData)!,
-            ...pool.linearDynamicData!,
             tokens: pool.tokens
                 .filter((token) => token.address !== pool.address)
                 .map((token) => {
@@ -1166,6 +1163,7 @@ export class PoolGqlLoaderService {
         return {
             __typename: 'GqlPoolComposableStableNested',
             ...pool,
+            ...(pool.staticTypeData as StableData)!,
             nestingType: this.getPoolNestingType(pool),
             tokens: pool.tokens.map((token) => {
                 const nestedPool = token.nestedPool;
@@ -1200,7 +1198,6 @@ export class PoolGqlLoaderService {
             totalLiquidity: `${pool.dynamicData?.totalLiquidity || 0}`,
             totalShares: pool.dynamicData?.totalShares || '0',
             swapFee: pool.dynamicData?.swapFee || '0',
-            amp: pool.stableDynamicData?.amp || '0',
             bptPriceRate: bpt?.dynamicData?.priceRate || '1.0',
         };
     }

diff --git a/modules/pool/lib/pool-on-chain-data.service.ts b/modules/pool/lib/pool-on-chain-data.service.ts
@@ -2,14 +2,14 @@ import { formatFixed } from '@ethersproject/bignumber';
 import { PrismaPoolType } from '@prisma/client';
 import { isSameAddress } from '@balancer-labs/sdk';
 import { prisma } from '../../../prisma/prisma-client';
-import { isComposableStablePool, isStablePool } from './pool-utils';
+import { isStablePool } from './pool-utils';
 import { TokenService } from '../../token/token.service';
 import { prismaBulkExecuteOperations } from '../../../prisma/prisma-util';
 import { fetchOnChainPoolState } from './pool-onchain-state';
 import { fetchOnChainPoolData } from './pool-onchain-data';
 import { fetchOnChainGyroFees } from './pool-onchain-gyro-fee';
 import { networkContext } from '../../network/network-context.service';
-import { LinearData } from '../subgraph-mapper';
+import { LinearData, StableData } from '../subgraph-mapper';
 
 const SUPPORTED_POOL_TYPES: PrismaPoolType[] = [
     'WEIGHTED',
@@ -89,9 +89,7 @@ export class PoolOnChainDataService {
             },
             include: {
                 tokens: { orderBy: { index: 'asc' }, include: { dynamicData: true, token: true } },
-                stableDynamicData: true,
                 dynamicData: true,
-                linearDynamicData: true,
             },
         });
 
@@ -120,12 +118,16 @@ export class PoolOnChainDataService {
                     }
 
                     //only update if amp has changed
-                    if (!pool.stableDynamicData || pool.stableDynamicData.amp !== amp) {
+                    if ((pool.staticTypeData as StableData).amp !== amp) {
                         operations.push(
-                            prisma.prismaPoolStableDynamicData.upsert({
+                            prisma.prismaPool.update({
                                 where: { id_chain: { id: pool.id, chain: this.options.chain } },
-                                create: { id: pool.id, chain: this.options.chain, poolId: pool.id, amp, blockNumber },
-                                update: { amp, blockNumber },
+                                data: {
+                                    staticTypeData: {
+                                        ...(pool.staticTypeData as StableData),
+                                        amp,
+                                    },
+                                },
                             }),
                         );
                     }
@@ -140,22 +142,19 @@ export class PoolOnChainDataService {
                         const upperTarget = formatFixed(onchainData.targets[1], 18);
 
                         if (
-                            !pool.linearDynamicData ||
-                            pool.linearDynamicData.lowerTarget !== lowerTarget ||
-                            pool.linearDynamicData.upperTarget !== upperTarget
+                            (pool.staticTypeData as LinearData).lowerTarget !== lowerTarget ||
+                            (pool.staticTypeData as LinearData).upperTarget !== upperTarget
                         ) {
                             operations.push(
-                                prisma.prismaPoolLinearDynamicData.upsert({
+                                prisma.prismaPool.update({
                                     where: { id_chain: { id: pool.id, chain: this.options.chain } },
-                                    create: {
-                                        id: pool.id,
-                                        chain: this.options.chain,
-                                        poolId: pool.id,
-                                        upperTarget,
-                                        lowerTarget,
-                                        blockNumber,
+                                    data: {
+                                        staticTypeData: {
+                                            ...(pool.staticTypeData as LinearData),
+                                            lowerTarget,
+                                            upperTarget,
+                                        },
                                     },
-                                    update: { upperTarget, lowerTarget, blockNumber },
                                 }),
                             );
                         }

diff --git a/modules/pool/pool-data/linear.ts b/modules/pool/pool-data/linear.ts
@@ -4,13 +4,7 @@ export const linear = (pool: BalancerPoolFragment) => {
     return {
         mainIndex: pool.mainIndex || 0,
         wrappedIndex: pool.wrappedIndex || 0,
-    };
-};
-
-export const linearDynamic = (pool: BalancerPoolFragment, blockNumber: number) => {
-    return {
-        upperTarget: pool.upperTarget || '',
-        lowerTarget: pool.lowerTarget || '',
-        blockNumber,
+        lowerTarget: pool.lowerTarget || '0',
+        upperTarget: pool.upperTarget || '0',
     };
 };
diff --git a/modules/pool/pool-data/stable.ts b/modules/pool/pool-data/stable.ts
@@ -1,8 +1,7 @@
 import { BalancerPoolFragment } from '../../subgraphs/balancer-subgraph/generated/balancer-subgraph-types';
 
-export const stableDynamic = (pool: BalancerPoolFragment, blockNumber: number) => {
+export const stable = (pool: BalancerPoolFragment) => {
     return {
         amp: pool.amp || '',
-        blockNumber,
     };
 };
diff --git a/modules/pool/pool.prisma b/modules/pool/pool.prisma
@@ -22,8 +22,6 @@ model PrismaPool {
     tokens              PrismaPoolToken[]
 
     dynamicData         PrismaPoolDynamicData?
-    stableDynamicData   PrismaPoolStableDynamicData?
-    linearDynamicData   PrismaPoolLinearDynamicData?
 
     snapshots           PrismaPoolSnapshot[]
     swaps               PrismaPoolSwap[]
@@ -119,35 +117,6 @@ model PrismaPoolDynamicData {
     fees24hAtlTimestamp     Int                 @default(0)
 }
 
-model PrismaPoolStableDynamicData {
-    @@id([id, chain])
-    @@unique([poolId, chain])
-
-    id                  String
-    poolId              String
-    pool                PrismaPool          @relation(fields:[poolId, chain], references: [id, chain], onDelete: Cascade)
-    chain               Chain
-    blockNumber         Int
-    updatedAt           DateTime            @updatedAt
-
-    amp                 String
-}
-
-model PrismaPoolLinearDynamicData {
-    @@id([id, chain])
-    @@unique([poolId, chain])
-
-    id                  String
-    poolId              String
-    pool                PrismaPool          @relation(fields:[poolId, chain], references: [id, chain], onDelete: Cascade)
-    chain               Chain
-    blockNumber         Int
-    updatedAt           DateTime            @updatedAt
-
-    lowerTarget         String
-    upperTarget         String
-}
-
 model PrismaPoolToken {
     @@id([id, chain])
 

diff --git a/modules/pool/subgraph-mapper.test.ts b/modules/pool/subgraph-mapper.test.ts
@@ -46,20 +46,20 @@ describe('subgraphToPrismaCreate', () => {
     it('should return correct object for stable pool', () => {
         const result = subgraphToPrismaCreate(stablePool, 'MAINNET', 1, []);
         expect(result.data.type).toBe('COMPOSABLE_STABLE');
-        expect(result.data.stableDynamicData?.create.amp).toBe(stablePool.amp);
+        expect(result.data.staticTypeData['amp']).toBe(stablePool.amp);
     });
 
     it('should return correct object for old stable pool', () => {
         const result = subgraphToPrismaCreate(oldStablePool, 'MAINNET', 1, []);
         expect(result.data.type).toBe('COMPOSABLE_STABLE');
         expect(result.data.version).toBe(0);
-        expect(result.data.stableDynamicData?.create.amp).toBe(oldStablePool.amp);
+        expect(result.data.staticTypeData['amp']).toBe(oldStablePool.amp);
     });
 
     it('should return correct object for linear pool', () => {
         const result = subgraphToPrismaCreate(linearPool, 'MAINNET', 1, []);
         expect(result.data.type).toBe('LINEAR');
-        expect(result.data.linearDynamicData?.create.upperTarget).toBe(linearPool.upperTarget);
+        expect(result.data.staticTypeData['upperTarget']).toBe(linearPool.upperTarget);
         expect(result.data.staticTypeData['wrappedIndex']).toBe(linearPool.wrappedIndex);
     });
 

diff --git a/modules/pool/subgraph-mapper.ts b/modules/pool/subgraph-mapper.ts
@@ -1,7 +1,7 @@
 import { Chain, PrismaPoolType } from '@prisma/client';
 import { BalancerPoolFragment } from '../subgraphs/balancer-subgraph/generated/balancer-subgraph-types';
 import { AddressZero } from '@ethersproject/constants';
-import { fx, gyro, linear, element, stableDynamic, linearDynamic } from './pool-data';
+import { fx, gyro, linear, element, stable } from './pool-data';
 
 export const subgraphToPrismaCreate = (
     pool: BalancerPoolFragment,
@@ -26,23 +26,6 @@ export const subgraphToPrismaCreate = (
                     ...dbData.dynamicData,
                 },
             },
-            linearDynamicData:
-                dbData.base.type === 'LINEAR'
-                    ? {
-                          create: {
-                              id: dbData.base.id,
-                              ...(dbData.dynamicTypeData as ReturnType<typeof dynamicTypeDataMapper['LINEAR']>),
-                          },
-                      }
-                    : undefined,
-            stableDynamicData: ['STABLE', 'COMPOSABLE_STABLE', 'META_STABLE'].includes(dbData.base.type)
-                ? {
-                      create: {
-                          id: dbData.base.id,
-                          ...(dbData.dynamicTypeData as ReturnType<typeof dynamicTypeDataMapper['STABLE']>),
-                      },
-                  }
-                : undefined,
         },
     };
 
@@ -74,21 +57,6 @@ export const subgraphToPrismaUpdate = (
                 },
             })),
         },
-        linearDynamicData:
-            dbData.base.type === 'LINEAR'
-                ? {
-                      update: {
-                          ...(dbData.dynamicTypeData as ReturnType<typeof dynamicTypeDataMapper['LINEAR']>),
-                      },
-                  }
-                : undefined,
-        stableDynamicData: ['STABLE', 'COMPOSABLE_STABLE', 'META_STABLE'].includes(dbData.base.type)
-            ? {
-                  update: {
-                      ...(dbData.dynamicTypeData as ReturnType<typeof dynamicTypeDataMapper['STABLE']>),
-                  },
-              }
-            : undefined,
     };
 
     return prismaPoolRecordWithDataAssociations;
@@ -132,10 +100,6 @@ const subgraphMapper = (
         ? staticTypeDataMapper[type as keyof typeof staticTypeDataMapper](pool)
         : {};
 
-    const dynamicTypeData = Object.keys(dynamicTypeDataMapper).includes(type)
-        ? dynamicTypeDataMapper[type as keyof typeof dynamicTypeDataMapper](pool, blockNumber)
-        : {};
-
     const tokens =
         pool.tokens?.map((token) => {
             const nestedPool = nestedPools.find((nestedPool) => {
@@ -165,7 +129,6 @@ const subgraphMapper = (
         dynamicData,
         tokens,
         staticTypeData,
-        dynamicTypeData,
     };
 };
 
@@ -225,18 +188,13 @@ const staticTypeDataMapper = {
     GYRO3: gyro,
     GYROE: gyro,
     LINEAR: linear,
-};
-
-const dynamicTypeDataMapper = {
-    STABLE: stableDynamic,
-    COMPOSABLE_STABLE: stableDynamic,
-    META_STABLE: stableDynamic,
-    LINEAR: linearDynamic,
+    STABLE: stable,
+    COMPOSABLE_STABLE: stable,
+    META_STABLE: stable,
 };
 
 export type FxData = ReturnType<typeof fx>;
 export type GyroData = ReturnType<typeof gyro>;
 export type LinearData = ReturnType<typeof linear>;
 export type ElementData = ReturnType<typeof element>;
-export type StableDynamicData = ReturnType<typeof stableDynamic>;
-export type LinearDynamicData = ReturnType<typeof linearDynamic>;
+export type StableData = ReturnType<typeof stable>;
diff --git a/modules/sor/sorV2/lib/pools/metastable/metastablePool.ts b/modules/sor/sorV2/lib/pools/metastable/metastablePool.ts
@@ -6,6 +6,7 @@ import { _calcInGivenOut, _calcOutGivenIn, _calculateInvariant } from '../stable
 import { MathSol, WAD } from '../../utils/math';
 import { BasePool, PoolType, SwapKind, Token, TokenAmount } from '@balancer/sdk';
 import { chainToIdMap } from '../../../../../network/network-config';
+import { StableData } from '../../../../../pool/subgraph-mapper';
 
 export class MetaStablePool implements BasePool {
     public readonly chain: Chain;
@@ -22,7 +23,7 @@ export class MetaStablePool implements BasePool {
     static fromPrismaPool(pool: PrismaPoolWithDynamic): MetaStablePool {
         const poolTokens: StablePoolToken[] = [];
 
-        if (!pool.dynamicData || !pool.stableDynamicData) throw new Error('Stable pool has no dynamic data');
+        if (!pool.dynamicData) throw new Error('Stable pool has no dynamic data');
 
         for (const poolToken of pool.tokens) {
             if (!poolToken.dynamicData?.priceRate) throw new Error('Meta Stable pool token does not have a price rate');
@@ -45,7 +46,7 @@ export class MetaStablePool implements BasePool {
             );
         }
 
-        const amp = parseUnits(pool.stableDynamicData.amp, 3);
+        const amp = parseUnits((pool.staticTypeData as StableData).amp, 3);
 
         return new MetaStablePool(
             pool.id as Hex,

diff --git a/modules/sor/sorV2/lib/pools/stable/stablePool.ts b/modules/sor/sorV2/lib/pools/stable/stablePool.ts
@@ -13,6 +13,7 @@ import {
 } from './stableMath';
 import { BasePool, BigintIsh, PoolType, SwapKind, Token, TokenAmount } from '@balancer/sdk';
 import { chainToIdMap } from '../../../../../network/network-config';
+import { StableData } from '../../../../../pool/subgraph-mapper';
 
 export class StablePoolToken extends TokenAmount {
     public readonly rate: bigint;
@@ -56,7 +57,7 @@ export class StablePool implements BasePool {
     static fromPrismaPool(pool: PrismaPoolWithDynamic): StablePool {
         const poolTokens: StablePoolToken[] = [];
 
-        if (!pool.dynamicData || !pool.stableDynamicData) throw new Error('Stable pool has no dynamic data');
+        if (!pool.dynamicData) throw new Error('Stable pool has no dynamic data');
 
         for (const poolToken of pool.tokens) {
             if (!poolToken.dynamicData?.priceRate) throw new Error('Stable pool token does not have a price rate');
@@ -80,7 +81,7 @@ export class StablePool implements BasePool {
         }
 
         const totalShares = parseEther(pool.dynamicData.totalShares);
-        const amp = parseUnits(pool.stableDynamicData.amp, 3);
+        const amp = parseUnits((pool.staticTypeData as StableData).amp, 3);
 
         return new StablePool(
             pool.id as Hex,