diff --git a/packages/envio/src/Config.gen.ts b/packages/envio/src/Config.gen.ts deleted file mode 100644 index b68badf25f..0000000000 --- a/packages/envio/src/Config.gen.ts +++ /dev/null @@ -1,19 +0,0 @@ -/* TypeScript file generated from Config.res by genType. */ - -/* eslint-disable */ -/* tslint:disable */ - -import type {t as Address_t} from './Address.gen.js'; - -export type DynamicContractRegistry_t = { - readonly id: string; - readonly chain_id: number; - readonly registering_event_block_number: number; - readonly registering_event_log_index: number; - readonly registering_event_block_timestamp: number; - readonly registering_event_contract_name: string; - readonly registering_event_name: string; - readonly registering_event_src_address: Address_t; - readonly contract_address: Address_t; - readonly contract_name: string -}; diff --git a/packages/envio/src/Config.res b/packages/envio/src/Config.res index 66062bc995..bba3bb4edd 100644 --- a/packages/envio/src/Config.res +++ b/packages/envio/src/Config.res @@ -86,38 +86,38 @@ type t = { allEnums: array>, } -module DynamicContractRegistry = { - let name = "dynamic_contract_registry" +module EnvioAddresses = { + let name = "envio_addresses" let index = -1 - let makeId = (~chainId, ~contractAddress) => { - chainId->Belt.Int.toString ++ "-" ++ contractAddress->Address.toString + let makeId = (~chainId, ~address) => { + chainId->Belt.Int.toString ++ "-" ++ address->Address.toString } - @genType type t = { id: string, @as("chain_id") chainId: int, - @as("registering_event_block_number") registeringEventBlockNumber: int, - @as("registering_event_log_index") registeringEventLogIndex: int, - @as("registering_event_block_timestamp") registeringEventBlockTimestamp: int, - @as("registering_event_contract_name") registeringEventContractName: string, - @as("registering_event_name") registeringEventName: string, - @as("registering_event_src_address") registeringEventSrcAddress: Address.t, - @as("contract_address") contractAddress: Address.t, + @as("registration_block") registrationBlock: int, + // -1 when the address was registered from a block handler (no log index) + @as("registration_log_index") registrationLogIndex: int, @as("contract_name") contractName: string, } + // Extract the raw contract address from the composite id ({chainId}-{address}). + // Inverse of makeId. Keep in sync with makeId above and the SUBSTRING SQL in + // InternalTable.Chains.makeGetInitialStateQuery. + let getAddress = (entity: t): Address.t => { + let sepIdx = entity.id->String.indexOf("-") + entity.id + ->String.slice(~start=sepIdx + 1, ~end=entity.id->String.length) + ->Address.unsafeFromString + } + let schema = S.schema(s => { id: s.matches(S.string), chainId: s.matches(S.int), - registeringEventBlockNumber: s.matches(S.int), - registeringEventLogIndex: s.matches(S.int), - registeringEventContractName: s.matches(S.string), - registeringEventName: s.matches(S.string), - registeringEventSrcAddress: s.matches(Address.schema), - registeringEventBlockTimestamp: s.matches(S.int), - contractAddress: s.matches(Address.schema), + registrationBlock: s.matches(S.int), + registrationLogIndex: s.matches(S.int), contractName: s.matches(S.string), }) @@ -128,13 +128,9 @@ module DynamicContractRegistry = { ~fields=[ Table.mkField("id", String, ~isPrimaryKey=true, ~fieldSchema=S.string), Table.mkField("chain_id", Int32, ~fieldSchema=S.int), - Table.mkField("registering_event_block_number", Int32, ~fieldSchema=S.int), - Table.mkField("registering_event_log_index", Int32, ~fieldSchema=S.int), - Table.mkField("registering_event_block_timestamp", Int32, ~fieldSchema=S.int), - Table.mkField("registering_event_contract_name", String, ~fieldSchema=S.string), - Table.mkField("registering_event_name", String, ~fieldSchema=S.string), - Table.mkField("registering_event_src_address", String, ~fieldSchema=Address.schema), - Table.mkField("contract_address", String, ~fieldSchema=Address.schema), + Table.mkField("registration_block", Int32, ~fieldSchema=S.int), + // -1 sentinel when registered from a block handler (no log index) + Table.mkField("registration_log_index", Int32, ~fieldSchema=S.int), Table.mkField("contract_name", String, ~fieldSchema=S.string), ], ) @@ -289,7 +285,7 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict (Table.BigInt({precision: ?prop["precision"]}), Utils.BigInt.schema->S.toUnknown) | "bigdecimal" => ( Table.BigDecimal({ - config: ?(prop["precision"]->Option.map(p => (p, prop["scale"]->Option.getOr(0)))), + config: ?prop["precision"]->Option.map(p => (p, prop["scale"]->Option.getOr(0))), }), BigDecimal.schema->S.toUnknown, ) @@ -736,7 +732,7 @@ let fromPublic = (publicConfigJson: JSON.t, ~maxAddrInPartition=5000) => { ->Option.getOr([]) ->parseEntitiesFromJson(~enumConfigsByName) - let allEntities = userEntities->Array.concat([DynamicContractRegistry.entityConfig]) + let allEntities = userEntities->Array.concat([EnvioAddresses.entityConfig]) let userEntitiesByName = userEntities diff --git a/packages/envio/src/Envio.gen.ts b/packages/envio/src/Envio.gen.ts index 7b43640066..19ba3a8601 100644 --- a/packages/envio/src/Envio.gen.ts +++ b/packages/envio/src/Envio.gen.ts @@ -9,7 +9,7 @@ import type {Effect as $$effect} from './Types.ts'; import type {Logger as $$logger} from './Types.ts'; -import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen.js'; +import type {S_t as RescriptSchema_S_t} from './RescriptSchema.gen.js'; export type blockEvent = { readonly number: number }; diff --git a/packages/envio/src/InMemoryStore.res b/packages/envio/src/InMemoryStore.res index 5d9a6ae94a..5d8bb49494 100644 --- a/packages/envio/src/InMemoryStore.res +++ b/packages/envio/src/InMemoryStore.res @@ -100,7 +100,7 @@ let isRollingBack = (inMemoryStore: t) => inMemoryStore.rollbackTargetCheckpoint let setBatchDcs = (inMemoryStore: t, ~batch: Batch.t, ~shouldSaveHistory) => { let inMemTable = - inMemoryStore->getInMemTable(~entityConfig=InternalTable.DynamicContractRegistry.entityConfig) + inMemoryStore->getInMemTable(~entityConfig=InternalTable.EnvioAddresses.entityConfig) let itemIdx = ref(0) @@ -118,24 +118,19 @@ let setBatchDcs = (inMemoryStore: t, ~batch: Batch.t, ~shouldSaveHistory) => { let eventItem = item->Internal.castUnsafeEventItem for dcIdx in 0 to dcs->Array.length - 1 { let dc = dcs->Array.getUnsafe(dcIdx) - let entity: InternalTable.DynamicContractRegistry.t = { - id: InternalTable.DynamicContractRegistry.makeId(~chainId, ~contractAddress=dc.address), + let entity: InternalTable.EnvioAddresses.t = { + id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address), chainId, - contractAddress: dc.address, contractName: dc.contractName, - registeringEventBlockNumber: eventItem.blockNumber, - registeringEventLogIndex: eventItem.logIndex, - registeringEventBlockTimestamp: eventItem.timestamp, - registeringEventContractName: eventItem.eventConfig.contractName, - registeringEventName: eventItem.eventConfig.name, - registeringEventSrcAddress: eventItem.event.srcAddress, + registrationBlock: eventItem.blockNumber, + registrationLogIndex: eventItem.logIndex, } inMemTable->InMemoryTable.Entity.set( Set({ entityId: entity.id, checkpointId, - entity: entity->InternalTable.DynamicContractRegistry.castToInternal, + entity: entity->InternalTable.EnvioAddresses.castToInternal, }), ~shouldSaveHistory, ) diff --git a/packages/envio/src/Persistence.res b/packages/envio/src/Persistence.res index 6a7f275919..379493c70f 100644 --- a/packages/envio/src/Persistence.res +++ b/packages/envio/src/Persistence.res @@ -142,7 +142,7 @@ let make = ( ~allEnums, ~storage, ) => { - let allEntities = userEntities->Array.concat([InternalTable.DynamicContractRegistry.entityConfig]) + let allEntities = userEntities->Array.concat([InternalTable.EnvioAddresses.entityConfig]) let allEnums = allEnums->Array.concat([EntityHistory.RowAction.config->Table.fromGenericEnumConfig]) { @@ -316,45 +316,46 @@ let prepareRollbackDiff = async ( let deletedEntities = Dict.make() let setEntities = Dict.make() - let _ = await persistence.allEntities - ->Belt.Array.map(async entityConfig => { - let entityTable = inMemStore->InMemoryStore.getInMemTable(~entityConfig) + let _ = + await persistence.allEntities + ->Belt.Array.map(async entityConfig => { + let entityTable = inMemStore->InMemoryStore.getInMemTable(~entityConfig) - let (removedIdsResult, restoredEntitiesResult) = await persistence.storage.getRollbackData( - ~entityConfig, - ~rollbackTargetCheckpointId, - ) - - // Process removed IDs - removedIdsResult->Array.forEach(data => { - deletedEntities->Utils.Dict.push(entityConfig.name, data["id"]) - entityTable->InMemoryTable.Entity.set( - Delete({ - entityId: data["id"], - checkpointId: rollbackDiffCheckpointId, - }), - ~shouldSaveHistory=false, - ~containsRollbackDiffChange=true, + let (removedIdsResult, restoredEntitiesResult) = await persistence.storage.getRollbackData( + ~entityConfig, + ~rollbackTargetCheckpointId, ) - }) - let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema) + // Process removed IDs + removedIdsResult->Array.forEach(data => { + deletedEntities->Utils.Dict.push(entityConfig.name, data["id"]) + entityTable->InMemoryTable.Entity.set( + Delete({ + entityId: data["id"], + checkpointId: rollbackDiffCheckpointId, + }), + ~shouldSaveHistory=false, + ~containsRollbackDiffChange=true, + ) + }) - // Process restored entities - restoredEntities->Belt.Array.forEach((entity: Internal.entity) => { - setEntities->Utils.Dict.push(entityConfig.name, entity.id) - entityTable->InMemoryTable.Entity.set( - Set({ - entityId: entity.id, - checkpointId: rollbackDiffCheckpointId, - entity, - }), - ~shouldSaveHistory=false, - ~containsRollbackDiffChange=true, - ) + let restoredEntities = restoredEntitiesResult->S.parseOrThrow(entityConfig.rowsSchema) + + // Process restored entities + restoredEntities->Belt.Array.forEach((entity: Internal.entity) => { + setEntities->Utils.Dict.push(entityConfig.name, entity.id) + entityTable->InMemoryTable.Entity.set( + Set({ + entityId: entity.id, + checkpointId: rollbackDiffCheckpointId, + entity, + }), + ~shouldSaveHistory=false, + ~containsRollbackDiffChange=true, + ) + }) }) - }) - ->Promise.all + ->Promise.all { "inMemStore": inMemStore, diff --git a/packages/envio/src/PgStorage.res b/packages/envio/src/PgStorage.res index 74e0eb32a1..9b46229ceb 100644 --- a/packages/envio/src/PgStorage.res +++ b/packages/envio/src/PgStorage.res @@ -503,7 +503,8 @@ let setOrThrow = async (sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema let isFullChunk = chunkSize === maxItemsPerQuery let params = data["convertOrThrow"](chunk->(Utils.magic: array<'item> => array)) - + // Use prepared query only for full batches where the cached query is reused. + // Partial chunks generate unique SQL each time, so preparation has no benefit. let response = isFullChunk ? sql->Postgres.preparedUnsafe(data["query"], params) : sql->Postgres.unpreparedUnsafe( diff --git a/packages/envio/src/TestIndexer.res b/packages/envio/src/TestIndexer.res index 4a8d9295b3..e0d0ff27da 100644 --- a/packages/envio/src/TestIndexer.res +++ b/packages/envio/src/TestIndexer.res @@ -34,18 +34,15 @@ type testIndexerState = { mutable processChanges: array, } -// Cast Internal.entity back to DynamicContractRegistry.t -external castFromDcRegistry: Internal.entity => InternalTable.DynamicContractRegistry.t = - "%identity" - -// Convert DynamicContractRegistry.t to Internal.indexingContract -let toIndexingContract = ( - dc: InternalTable.DynamicContractRegistry.t, -): Internal.indexingContract => { - address: dc.contractAddress, +// Cast Internal.entity back to EnvioAddresses.t +external castToEnvioAddresses: Internal.entity => InternalTable.EnvioAddresses.t = "%identity" + +// Convert EnvioAddresses.t to Internal.indexingContract +let toIndexingContract = (dc: InternalTable.EnvioAddresses.t): Internal.indexingContract => { + address: dc->Config.EnvioAddresses.getAddress, contractName: dc.contractName, - startBlock: dc.registeringEventBlockNumber, - registrationBlock: Some(dc.registeringEventBlockNumber), + startBlock: dc.registrationBlock, + registrationBlock: Some(dc.registrationBlock), } let handleLoadByIds = ( @@ -224,34 +221,41 @@ let handleWriteBatch = ( entityChanges ->Dict.toArray ->Array.forEach(((entityName, {sets, deleted})) => { - // Transform dynamic_contract_registry to addresses with simplified structure - if entityName === InternalTable.DynamicContractRegistry.name { + // Transform envio_addresses to addresses with simplified structure + if entityName === InternalTable.EnvioAddresses.name { let entityObj: dict = Dict.make() if sets->Array.length > 0 { // Transform sets to simplified {address, contract} objects let simplifiedSets = sets->Array.map(entity => { - let dc = entity->Utils.magic->castFromDcRegistry - {"address": dc.contractAddress, "contract": dc.contractName} + let dc = entity->Utils.magic->castToEnvioAddresses + {"address": dc->Config.EnvioAddresses.getAddress, "contract": dc.contractName} }) - entityObj->Dict.set("sets", simplifiedSets->Utils.magic) + entityObj->Dict.set( + "sets", + simplifiedSets->( + Utils.magic: array<{"address": Address.t, "contract": string}> => unknown + ), + ) } // Note: deleted is not relevant for addresses since we use address string directly - change->Dict.set("addresses", entityObj->Utils.magic) + change->Dict.set("addresses", entityObj->(Utils.magic: dict => unknown)) } else { let entityObj: dict = Dict.make() if sets->Array.length > 0 { - entityObj->Dict.set("sets", sets->Utils.magic) + entityObj->Dict.set("sets", sets->(Utils.magic: array => unknown)) } if deleted->Array.length > 0 { - entityObj->Dict.set("deleted", deleted->Utils.magic) + entityObj->Dict.set("deleted", deleted->(Utils.magic: array => unknown)) } - change->Dict.set(entityName, entityObj->Utils.magic) + change->Dict.set(entityName, entityObj->(Utils.magic: dict => unknown)) } }) | None => () } - state.processChanges->Array.push(change->Utils.magic)->ignore + state.processChanges + ->Array.push(change->(Utils.magic: dict => unknown)) + ->ignore } } @@ -523,8 +527,8 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): ( // Build entity operations for each user entity let entityOpsDict: dict = Dict.make() allEntities->Array.forEach(entityConfig => { - // Only create ops for user entities (not internal tables like dynamic_contract_registry) - if entityConfig.name !== InternalTable.DynamicContractRegistry.name { + // Only create ops for user entities (not internal tables like envio_addresses) + if entityConfig.name !== InternalTable.EnvioAddresses.name { entityOpsDict->Dict.set( entityConfig.name, { @@ -580,15 +584,15 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): ( // Start with static config addresses let addresses = contract.addresses->Array.copy // Add accumulated dynamic contract addresses - switch state.entities->Dict.get(InternalTable.DynamicContractRegistry.name) { + switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) { | Some(dcDict) => dcDict ->Dict.valuesToArray ->Array.forEach( entity => { - let dc = entity->castFromDcRegistry + let dc = entity->castToEnvioAddresses if dc.contractName === contract.name && dc.chainId === chainConfig.id { - addresses->Array.push(dc.contractAddress)->ignore + addresses->Array.push(dc->Config.EnvioAddresses.getAddress)->ignore } }, ) @@ -699,12 +703,12 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): ( // Extract dynamic contracts from state.entities for each chain let dynamicContractsByChain: dict> = Dict.make() - switch state.entities->Dict.get(InternalTable.DynamicContractRegistry.name) { + switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) { | Some(dcDict) => dcDict ->Dict.valuesToArray ->Array.forEach(entity => { - let dc = entity->castFromDcRegistry + let dc = entity->castToEnvioAddresses let dcChainIdStr = dc.chainId->Int.toString let contracts = switch dynamicContractsByChain->Dict.get(dcChainIdStr) { | Some(arr) => arr diff --git a/packages/envio/src/Utils.gen.ts b/packages/envio/src/Utils.gen.ts index a3d21e232d..653d36862d 100644 --- a/packages/envio/src/Utils.gen.ts +++ b/packages/envio/src/Utils.gen.ts @@ -5,6 +5,6 @@ import * as UtilsJS from './Utils.res.mjs'; -import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen.js'; +import type {S_t as RescriptSchema_S_t} from './RescriptSchema.gen.js'; export const bigIntSchema: RescriptSchema_S_t = UtilsJS.bigIntSchema as any; diff --git a/packages/envio/src/bindings/BigDecimal.gen.ts b/packages/envio/src/bindings/BigDecimal.gen.ts index 67607a0197..1ea39027af 100644 --- a/packages/envio/src/bindings/BigDecimal.gen.ts +++ b/packages/envio/src/bindings/BigDecimal.gen.ts @@ -5,7 +5,7 @@ import * as BigDecimalJS from './BigDecimal.res.mjs'; -import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen.js'; +import type {S_t as RescriptSchema_S_t} from './RescriptSchema.gen.js'; import type {default as $$t} from 'bignumber.js'; diff --git a/packages/envio/src/db/InternalTable.gen.ts b/packages/envio/src/db/InternalTable.gen.ts index 6013e6203f..e64a87158a 100644 --- a/packages/envio/src/db/InternalTable.gen.ts +++ b/packages/envio/src/db/InternalTable.gen.ts @@ -5,19 +5,6 @@ import type {t as Address_t} from '../../src/Address.gen.js'; -export type DynamicContractRegistry_t = { - readonly id: string; - readonly chain_id: number; - readonly registering_event_block_number: number; - readonly registering_event_log_index: number; - readonly registering_event_block_timestamp: number; - readonly registering_event_contract_name: string; - readonly registering_event_name: string; - readonly registering_event_src_address: Address_t; - readonly contract_address: Address_t; - readonly contract_name: string -}; - export type RawEvents_t = { readonly chain_id: number; readonly event_id: bigint; diff --git a/packages/envio/src/db/InternalTable.res b/packages/envio/src/db/InternalTable.res index 8ca764ab80..2d8193eabc 100644 --- a/packages/envio/src/db/InternalTable.res +++ b/packages/envio/src/db/InternalTable.res @@ -5,7 +5,7 @@ let isPrimaryKey = true let isNullable = true let isIndex = true -module DynamicContractRegistry = Config.DynamicContractRegistry +module EnvioAddresses = Config.EnvioAddresses module Chains = { type progressFields = [ @@ -192,13 +192,16 @@ WHERE "${(#id: field :> string)}" = $1;` "${(#progress_block: field :> string)}" as "progressBlockNumber", "${(#source_block: field :> string)}" as "sourceBlockNumber", ( + -- envio_addresses.id is a composite "{chainId}-{address}" string produced by + -- Config.EnvioAddresses.makeId; extract the address by taking everything + -- after the first '-'. Keep in sync with makeId / getAddress. SELECT COALESCE(json_agg(json_build_object( - 'address', "contract_address", + 'address', SUBSTRING("id" FROM POSITION('-' IN "id") + 1), 'contractName', "contract_name", - 'startBlock', "registering_event_block_number", - 'registrationBlock', "registering_event_block_number" + 'startBlock', "registration_block", + 'registrationBlock', "registration_block" )), '[]'::json) - FROM "${pgSchema}"."${DynamicContractRegistry.table.tableName}" + FROM "${pgSchema}"."${EnvioAddresses.table.tableName}" WHERE "chain_id" = chains."${(#id: field :> string)}" ) as "dynamicContracts" FROM "${pgSchema}"."${table.tableName}" as chains;` diff --git a/scenarios/test_codegen/test/integration-raw-events.test.ts b/scenarios/test_codegen/test/integration-raw-events.test.ts index 472c47c379..975183dff6 100644 --- a/scenarios/test_codegen/test/integration-raw-events.test.ts +++ b/scenarios/test_codegen/test/integration-raw-events.test.ts @@ -108,8 +108,8 @@ // expect(rowsToken.count).to.be.gt(0); // }); -// it("should have 1 row in the dynamic_contract_registry table", async function () { -// let rowsDCR = await sql`SELECT * FROM public.dynamic_contract_registry`; +// it("should have 1 row in the envio_addresses table", async function () { +// let rowsDCR = await sql`SELECT * FROM public.envio_addresses`; // console.log(rowsDCR); // expect(rowsDCR.count).to.be.eq(1); // }); diff --git a/scenarios/test_codegen/test/lib_tests/Persistence_test.res b/scenarios/test_codegen/test/lib_tests/Persistence_test.res index 5358373e7f..278a76acbd 100644 --- a/scenarios/test_codegen/test/lib_tests/Persistence_test.res +++ b/scenarios/test_codegen/test/lib_tests/Persistence_test.res @@ -9,7 +9,7 @@ describe("Test Persistence layer init", () => { t.expect( persistence.allEntities, ~message=`All entities should automatically include the indexer core ones`, - ).toEqual([InternalTable.DynamicContractRegistry.entityConfig]) + ).toEqual([InternalTable.EnvioAddresses.entityConfig]) t.expect( persistence.allEnums, ~message=`All enums should automatically include the indexer core ones`, diff --git a/scenarios/test_codegen/test/lib_tests/PgStorage_test.res b/scenarios/test_codegen/test/lib_tests/PgStorage_test.res index c19a504263..90be6880ee 100644 --- a/scenarios/test_codegen/test/lib_tests/PgStorage_test.res +++ b/scenarios/test_codegen/test/lib_tests/PgStorage_test.res @@ -817,13 +817,16 @@ VALUES (1, 100, 200, 5, 0, NULL, -1, -1, NULL, 0, false), "progress_block" as "progressBlockNumber", "source_block" as "sourceBlockNumber", ( + -- envio_addresses.id is a composite "{chainId}-{address}" string produced by + -- Config.EnvioAddresses.makeId; extract the address by taking everything + -- after the first '-'. Keep in sync with makeId / getAddress. SELECT COALESCE(json_agg(json_build_object( - 'address', "contract_address", + 'address', SUBSTRING("id" FROM POSITION('-' IN "id") + 1), 'contractName', "contract_name", - 'startBlock', "registering_event_block_number", - 'registrationBlock', "registering_event_block_number" + 'startBlock', "registration_block", + 'registrationBlock', "registration_block" )), '[]'::json) - FROM "test_schema"."dynamic_contract_registry" + FROM "test_schema"."envio_addresses" WHERE "chain_id" = chains."id" ) as "dynamicContracts" FROM "test_schema"."envio_chains" as chains;` diff --git a/scenarios/test_codegen/test/rollback/Rollback_test.res b/scenarios/test_codegen/test/rollback/Rollback_test.res index c62acfa658..423917d6f9 100644 --- a/scenarios/test_codegen/test/rollback/Rollback_test.res +++ b/scenarios/test_codegen/test/rollback/Rollback_test.res @@ -688,7 +688,7 @@ describe("E2E rollback tests", () => { ), ) t.expect( - await (indexerMock.queryRaw(InternalTable.DynamicContractRegistry.entityConfig): promise>), + await (indexerMock.queryRaw(InternalTable.EnvioAddresses.entityConfig): promise>), ~message="Shouldn't store dynamic contracts at this point", ).toEqual( [], @@ -729,20 +729,17 @@ describe("E2E rollback tests", () => { ), ) t.expect( - await (indexerMock.queryRaw(InternalTable.DynamicContractRegistry.entityConfig): promise>), + await (indexerMock.queryRaw(InternalTable.EnvioAddresses.entityConfig): promise< + array, + >), ~message="Added the processed dynamic contract to the db", ).toEqual( [ { id: `1337-${Envio.TestHelpers.Addresses.mockAddresses->Array.getUnsafe(0)->Address.toString}`, chainId: 1337, - registeringEventBlockNumber: 102, - registeringEventLogIndex: 2, - registeringEventBlockTimestamp: 102, - registeringEventContractName: "MockContract", - registeringEventName: "MockEvent", - registeringEventSrcAddress: "0x0000000000000000000000000000000000000000"->Address.unsafeFromString, - contractAddress: Envio.TestHelpers.Addresses.mockAddresses->Array.getUnsafe(0), + registrationBlock: 102, + registrationLogIndex: 2, contractName: "SimpleNft", }, ], @@ -751,7 +748,7 @@ describe("E2E rollback tests", () => { sourceMock.resolveGetItemsOrThrow([], ~resolveAt=#last, ~latestFetchedBlockNumber=103) await indexerMock.getBatchWritePromise() t.expect( - (await (indexerMock.queryRaw(InternalTable.DynamicContractRegistry.entityConfig): promise>))->Array.length, + (await (indexerMock.queryRaw(InternalTable.EnvioAddresses.entityConfig): promise>))->Array.length, ~message="Should add the processed dynamic contracts to the db", ).toEqual( 2, @@ -814,7 +811,7 @@ describe("E2E rollback tests", () => { await Utils.delay(0) await Utils.delay(0) t.expect( - (await (indexerMock.queryRaw(InternalTable.DynamicContractRegistry.entityConfig): promise>))->Array.length, + (await (indexerMock.queryRaw(InternalTable.EnvioAddresses.entityConfig): promise>))->Array.length, ~message=`Nothing won't be rollbacked at this point. Since we need to process an event for this (rollback db only on batch write). This might be wrong after we start exposing a block hash for progress block.`, ).toEqual( @@ -836,20 +833,17 @@ This might be wrong after we start exposing a block hash for progress block.`, await indexerMock.getBatchWritePromise() t.expect( - await (indexerMock.queryRaw(InternalTable.DynamicContractRegistry.entityConfig): promise>), + await (indexerMock.queryRaw(InternalTable.EnvioAddresses.entityConfig): promise< + array, + >), ~message="Should have only one dynamic contract in the db. The second one rollbacked from db, the third one rollbacked from fetch state", ).toEqual( [ { id: `1337-${Envio.TestHelpers.Addresses.mockAddresses->Array.getUnsafe(0)->Address.toString}`, chainId: 1337, - registeringEventBlockNumber: 102, - registeringEventLogIndex: 2, - registeringEventBlockTimestamp: 102, - registeringEventContractName: "MockContract", - registeringEventName: "MockEvent", - registeringEventSrcAddress: "0x0000000000000000000000000000000000000000"->Address.unsafeFromString, - contractAddress: Envio.TestHelpers.Addresses.mockAddresses->Array.getUnsafe(0), + registrationBlock: 102, + registrationLogIndex: 2, contractName: "SimpleNft", }, ],