@cardano-sdk/e2e 0.24.0 → 0.26.0

package/test/long-running/multisig-wallet/multisig-delegation-rewards.test.ts

@@ -0,0 +1,318 @@
+import * as Crypto from '@cardano-sdk/crypto';
+import { Cardano, EraSummary, StakePoolProvider, createSlotEpochCalc } from '@cardano-sdk/core';
+import { InMemoryKeyAgent, KeyRole } from '@cardano-sdk/key-management';
+import { MultiSigTx } from './MultiSigTx';
+import { MultiSigWallet } from './MultiSigWallet';
+import { Observable, filter, firstValueFrom, map, take } from 'rxjs';
+import { PersonalWallet } from '@cardano-sdk/wallet';
+import { TrackerSubject } from '@cardano-sdk/util-rxjs';
+import {
+  bip32Ed25519Factory,
+  createStandaloneKeyAgent,
+  getEnv,
+  getWallet,
+  waitForEpoch,
+  walletReady,
+  walletVariables
+} from '../../../src';
+import { isNotNil } from '@cardano-sdk/util';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv(walletVariables);
+
+// eslint-disable-next-line max-len
+const aliceMnemonics =
+  'decorate survey empower stairs pledge humble social leisure baby wrap grief exact monster rug dash kiss perfect select science light frame play swallow day';
+
+// eslint-disable-next-line max-len
+const bobMnemonics =
+  'salon zoo engage submit smile frost later decide wing sight chaos renew lizard rely canal coral scene hobby scare step bus leaf tobacco slice';
+
+// eslint-disable-next-line max-len
+const charlotteMnemonics =
+  'phrase raw learn suspect inmate powder combine apology regular hero gain chronic fruit ritual short screen goddess odor keen creek brand today kit machine';
+
+const DERIVATION_PATH = {
+  index: 0,
+  role: KeyRole.External
+};
+
+const getPoolIds = async (stakePoolProvider: StakePoolProvider, count: number) => {
+  const activePools = await stakePoolProvider.queryStakePools({
+    filters: { pledgeMet: true, status: [Cardano.StakePoolStatus.Active] },
+    pagination: { limit: count, startAt: 0 }
+  });
+  expect(activePools.totalResultCount).toBeGreaterThanOrEqual(count);
+  const poolIds = activePools.pageResults.map(({ id }) => id);
+  expect(poolIds.every((poolId) => poolId !== undefined)).toBeTruthy();
+  logger.info('Wallet funds will be staked to pools:', poolIds);
+  return poolIds;
+};
+
+const fundMultiSigWallet = async (sendingWallet: PersonalWallet, address: Cardano.PaymentAddress) => {
+  logger.info(`Funding multisig wallet with address: ${address}`);
+
+  const tAdaToSend = 5_000_000n;
+
+  const txBuilder = sendingWallet.createTxBuilder();
+  const txOut = await txBuilder.buildOutput().address(address).coin(tAdaToSend).build();
+  const { tx: signedTx } = await txBuilder.addOutput(txOut).build().sign();
+  await sendingWallet.submitTx(signedTx);
+};
+
+const getKeyAgent = async (mnemonics: string, faucetWallet: PersonalWallet, bip32Ed25519: Crypto.Bip32Ed25519) => {
+  const genesis = await firstValueFrom(faucetWallet.genesisParameters$);
+
+  const keyAgent = await createStandaloneKeyAgent(mnemonics.split(' '), genesis, bip32Ed25519);
+
+  const pubKey = await keyAgent.derivePublicKey(DERIVATION_PATH);
+
+  return { keyAgent, pubKey };
+};
+
+const generateTxs = async (sendingWallet: PersonalWallet, receivingWallet: PersonalWallet) => {
+  logger.info('Sending 100 txs to generate reward fees');
+
+  const tAdaToSend = 5_000_000n;
+  const [{ address: receivingAddress }] = await firstValueFrom(receivingWallet.addresses$);
+
+  for (let i = 0; i < 100; i++) {
+    const txBuilder = sendingWallet.createTxBuilder();
+    const txOut = await txBuilder.buildOutput().address(receivingAddress).coin(tAdaToSend).build();
+    const { tx: signedTx } = await txBuilder.addOutput(txOut).build().sign();
+    await sendingWallet.submitTx(signedTx);
+  }
+};
+
+const createMultiSignWallet = async (
+  keyAgent: InMemoryKeyAgent,
+  faucetWallet: PersonalWallet,
+  participants: Array<Crypto.Ed25519PublicKeyHex>
+) => {
+  const props = {
+    chainHistoryProvider: faucetWallet.chainHistoryProvider,
+    expectedSigners: participants,
+    inMemoryKeyAgent: keyAgent,
+    networkId: env.KEY_MANAGEMENT_PARAMS.chainId.networkId,
+    networkInfoProvider: faucetWallet.networkInfoProvider,
+    pollingInterval: 50,
+    rewardsProvider: faucetWallet.rewardsProvider,
+    txSubmitProvider: faucetWallet.txSubmitProvider,
+    utxoProvider: faucetWallet.utxoProvider
+  };
+
+  return await MultiSigWallet.createMultiSigWallet(props);
+};
+
+const getTxConfirmationEpoch = async (
+  history$: Observable<Cardano.HydratedTx[]>,
+  tx: Cardano.Tx<Cardano.TxBody>,
+  eraSummaries$: TrackerSubject<EraSummary[]>
+) => {
+  const txs = await firstValueFrom(history$.pipe(filter((_) => _.some(({ id }) => id === tx.id))));
+  const observedTx = txs.find(({ id }) => id === tx.id);
+  const slotEpochCalc = createSlotEpochCalc(await firstValueFrom(eraSummaries$));
+
+  return slotEpochCalc(observedTx!.blockHeader.slot);
+};
+
+describe('multi signature wallet', () => {
+  let faucetWallet: PersonalWallet;
+  let aliceKeyAgent: InMemoryKeyAgent;
+  let bobKeyAgent: InMemoryKeyAgent;
+  let charlotteKeyAgent: InMemoryKeyAgent;
+  let alicePubKey: Crypto.Ed25519PublicKeyHex;
+  let bobPubKey: Crypto.Ed25519PublicKeyHex;
+  let charlottePubKey: Crypto.Ed25519PublicKeyHex;
+  let faucetAddress: Cardano.PaymentAddress;
+  let aliceMultiSigWallet: MultiSigWallet;
+  let bobMultiSigWallet: MultiSigWallet;
+  let charlotteMultiSigWallet: MultiSigWallet;
+  let multiSigParticipants: Crypto.Ed25519PublicKeyHex[];
+
+  const initializeFaucet = async () => {
+    ({ wallet: faucetWallet } = await getWallet({
+      env,
+      logger,
+      name: 'Faucet Wallet',
+      polling: { interval: 50 }
+    }));
+
+    await walletReady(faucetWallet);
+  };
+
+  beforeAll(async () => {
+    await initializeFaucet();
+    const bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
+
+    ({ keyAgent: aliceKeyAgent, pubKey: alicePubKey } = await getKeyAgent(aliceMnemonics, faucetWallet, bip32Ed25519));
+    ({ keyAgent: bobKeyAgent, pubKey: bobPubKey } = await getKeyAgent(bobMnemonics, faucetWallet, bip32Ed25519));
+    ({ keyAgent: charlotteKeyAgent, pubKey: charlottePubKey } = await getKeyAgent(
+      charlotteMnemonics,
+      faucetWallet,
+      bip32Ed25519
+    ));
+
+    faucetAddress = (await firstValueFrom(faucetWallet.addresses$))[0].address;
+
+    multiSigParticipants = [alicePubKey, bobPubKey, charlottePubKey];
+
+    aliceMultiSigWallet = await createMultiSignWallet(aliceKeyAgent, faucetWallet, multiSigParticipants);
+    bobMultiSigWallet = await createMultiSignWallet(bobKeyAgent, faucetWallet, multiSigParticipants);
+    charlotteMultiSigWallet = await createMultiSignWallet(charlotteKeyAgent, faucetWallet, multiSigParticipants);
+  });
+
+  afterAll(() => {
+    faucetWallet?.shutdown();
+  });
+
+  it('can receive balance and can spend balance', async () => {
+    expect(aliceMultiSigWallet.getPaymentAddress()).toEqual(bobMultiSigWallet.getPaymentAddress());
+    expect(aliceMultiSigWallet.getPaymentAddress()).toEqual(charlotteMultiSigWallet.getPaymentAddress());
+
+    await fundMultiSigWallet(faucetWallet, bobMultiSigWallet.getPaymentAddress());
+
+    const multiSigWalletBalance = await firstValueFrom(
+      bobMultiSigWallet.getBalance().pipe(
+        map((value) => value.coins),
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletBalance).toBeGreaterThan(0n);
+
+    // Alice will initiate the transaction on her wallet.
+    let tx = await aliceMultiSigWallet.transferFunds(faucetAddress, { coins: 2_000_000n });
+
+    // Alice then signs the transaction and relay it to Bob.
+    tx = await aliceMultiSigWallet.sign(tx);
+    const aliceSerializedTx = tx.toCbor();
+
+    // .... Bob receives the transaction and signs it.
+    let bobTx = MultiSigTx.fromCbor(aliceSerializedTx);
+    bobTx = await bobMultiSigWallet.sign(bobTx);
+
+    // Bob can then check if there are any missing signatures. If there are, he can then
+    // check who is missing and send the transaction to them.
+    expect(bobTx.isFullySigned()).toBe(false);
+    expect(bobTx.getMissingSigners()).toEqual([charlottePubKey]);
+
+    const bobSerializedTx = bobTx.toCbor();
+
+    // .... Charlotte receives the transaction and signs it.
+    let charlotteTx = MultiSigTx.fromCbor(bobSerializedTx);
+    charlotteTx = await charlotteMultiSigWallet.sign(charlotteTx);
+
+    // Charlotte can then check if there are any missing signatures. And if all signatures
+    // are complete she can submit it to the network.
+    expect(charlotteTx.getMissingSigners()).toEqual([]);
+    expect(charlotteTx.isFullySigned()).toBe(true);
+    const txId = await charlotteMultiSigWallet.submit(charlotteTx);
+
+    // Search chain history to see if the transaction is there.
+    const txFoundInHistory = await firstValueFrom(
+      faucetWallet.transactions.history$.pipe(
+        map((txs) => txs.find((hTx) => hTx.id === txId)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(txFoundInHistory).toBeTruthy();
+  });
+
+  // eslint-disable-next-line max-statements
+  it('delegate to a pool and claim rewards', async () => {
+    expect(aliceMultiSigWallet.getRewardAccount()).toEqual(bobMultiSigWallet.getRewardAccount());
+    expect(aliceMultiSigWallet.getRewardAccount()).toEqual(charlotteMultiSigWallet.getRewardAccount());
+
+    await fundMultiSigWallet(faucetWallet, bobMultiSigWallet.getPaymentAddress());
+
+    const multiSigWalletBalance = await firstValueFrom(
+      bobMultiSigWallet.getBalance().pipe(
+        map((value) => value.coins),
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletBalance).toBeGreaterThan(0n);
+
+    const [poolId] = await getPoolIds(faucetWallet.stakePoolProvider, 1);
+
+    // Alice will initiate the delegation transaction on her wallet.
+    let tx = await aliceMultiSigWallet.delegate(poolId);
+    tx = await aliceMultiSigWallet.sign(tx);
+    tx = await bobMultiSigWallet.sign(tx);
+    tx = await charlotteMultiSigWallet.sign(tx);
+
+    const txId = await charlotteMultiSigWallet.submit(tx);
+
+    // Search chain history to see if the transaction is there.
+    const txFoundInHistory = await firstValueFrom(
+      charlotteMultiSigWallet.getTransactionHistory().pipe(
+        map((txs) => txs.find((hTx) => hTx.id === txId)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(txFoundInHistory).toBeTruthy();
+
+    // Delegation is completed. Now we wait for rewards to be available.
+    const delegationTxConfirmedAtEpoch = await getTxConfirmationEpoch(
+      charlotteMultiSigWallet.getTransactionHistory(),
+      tx.getTransaction(),
+      faucetWallet.eraSummaries$
+    );
+
+    logger.info(`Delegation tx confirmed at epoch #${delegationTxConfirmedAtEpoch}`);
+
+    await waitForEpoch(faucetWallet, delegationTxConfirmedAtEpoch + 2);
+    await generateTxs(faucetWallet, faucetWallet);
+    await waitForEpoch(faucetWallet, delegationTxConfirmedAtEpoch + 4);
+
+    // Check reward
+    const multiSigWalletRewardBalance = await firstValueFrom(
+      bobMultiSigWallet.getRewardAccountBalance().pipe(
+        filter((value) => value > 0n),
+        take(1)
+      )
+    );
+
+    expect(multiSigWalletRewardBalance).toBeGreaterThan(0n);
+
+    logger.info(`Generated rewards: ${multiSigWalletRewardBalance} tLovelace`);
+
+    tx = await aliceMultiSigWallet.transferFunds(faucetAddress, { coins: 2_000_000n });
+    expect(tx.getTransaction().body.withdrawals?.length).toBeGreaterThan(0);
+
+    tx = await aliceMultiSigWallet.sign(tx);
+    tx = await bobMultiSigWallet.sign(tx);
+    tx = await charlotteMultiSigWallet.sign(tx);
+
+    const spendRewardsTx = await charlotteMultiSigWallet.submit(tx);
+
+    // Search chain history to see if the transaction is there.
+    const spendRewardsTxFoundInHistory = await firstValueFrom(
+      faucetWallet.transactions.history$.pipe(
+        map((txs) => txs.find((hTx) => hTx.id === spendRewardsTx)),
+        filter(isNotNil),
+        take(1)
+      )
+    );
+
+    expect(spendRewardsTxFoundInHistory).toBeTruthy();
+
+    // Check reward
+    const finalRewardBalance = await firstValueFrom(
+      bobMultiSigWallet.getRewardAccountBalance().pipe(
+        filter((value) => value === 0n),
+        take(1)
+      )
+    );
+
+    expect(finalRewardBalance).toEqual(0n);
+  });
+});

package/test/projection/offline-fork.test.ts

@@ -1,10 +1,10 @@
-/* eslint-disable promise/always-return */
 import * as Postgres from '@cardano-sdk/projection-typeorm';
 import { BlockDataEntity, BlockEntity, StakeKeyEntity } from '@cardano-sdk/projection-typeorm';
 import {
   Bootstrap,
   InMemory,
   Mappers,
+  ProjectionEvent,
   ProjectionOperator,
   StabilityWindowBuffer,
   WithBlock,
@@ -17,16 +17,18 @@ import {
   ChainSyncEventType,
   ChainSyncRollForward,
   ObservableCardanoNode,
-  Point
+  Point,
+  TipOrOrigin
 } from '@cardano-sdk/core';
 import { ChainSyncDataSet, chainSyncData, logger } from '@cardano-sdk/util-dev';
 import { ConnectionConfig } from '@cardano-ogmios/client';
-import { Observable, filter, firstValueFrom, lastValueFrom, of, take, takeWhile, toArray } from 'rxjs';
+import { Observable, filter, firstValueFrom, lastValueFrom, map, of, take, takeWhile, toArray } from 'rxjs';
 import { OgmiosObservableCardanoNode } from '@cardano-sdk/ogmios';
+import { ReconnectionConfig } from '@cardano-sdk/util-rxjs';
 import { createDatabase } from 'typeorm-extension';
 import { getEnv } from '../../src';
 
-const dataWithStakeKeyDeregistration = chainSyncData(ChainSyncDataSet.WithStakeKeyDeregistration);
+const dataWithStakeDeregistration = chainSyncData(ChainSyncDataSet.WithStakeKeyDeregistration);
 
 const ogmiosConnectionConfig = ((): ConnectionConfig => {
   const { OGMIOS_URL } = getEnv(['OGMIOS_URL']);
@@ -64,22 +66,22 @@ const createForkProjectionSource = (
   // eslint-disable-next-line sort-keys-fix/sort-keys-fix
   findIntersect: (points) => {
     const intersectionPoint = points[0] as Point;
-    const someEventsWithStakeKeyRegistration = dataWithStakeKeyDeregistration.allEvents
+    const someEventsWithStakeRegistration = dataWithStakeDeregistration.allEvents
       .filter(
         (evt): evt is Omit<ChainSyncRollForward, 'requestNext'> =>
           evt.eventType === ChainSyncEventType.RollForward &&
           evt.block.body.some((tx) =>
-            tx.body.certificates?.some((cert) => cert.__typename === Cardano.CertificateType.StakeKeyRegistration)
+            tx.body.certificates?.some((cert) => cert.__typename === Cardano.CertificateType.StakeRegistration)
           )
       )
       .slice(0, 2);
     return of({
       chainSync$: new Observable<ChainSyncEvent>((subscriber) => {
-        const events = [...someEventsWithStakeKeyRegistration];
+        const events = [...someEventsWithStakeRegistration];
         const next = () => {
           const nextEvt = events.shift();
           if (nextEvt) {
-            const blockOffset = someEventsWithStakeKeyRegistration.length - events.length;
+            const blockOffset = someEventsWithStakeRegistration.length - events.length;
             const slot = Cardano.Slot(intersectionPoint.slot + blockOffset * 20);
             const blockNo = Cardano.BlockNo(lastEvt.block.header.blockNo + blockOffset);
             subscriber.next({
@@ -102,13 +104,21 @@ const createForkProjectionSource = (
       }),
       intersection: {
         point: intersectionPoint,
-        tip: someEventsWithStakeKeyRegistration[someEventsWithStakeKeyRegistration.length - 1].tip
+        tip: someEventsWithStakeRegistration[someEventsWithStakeRegistration.length - 1].tip
       }
     });
   },
   healthCheck$: new Observable()
 });
 
+const fakeTip = <T extends ProjectionEvent>(evt$: Observable<T>): Observable<T> =>
+  evt$.pipe(
+    map((evt) => ({
+      ...evt,
+      tip: evt.block.header
+    }))
+  );
+
 describe('resuming projection when intersection is not local tip', () => {
   let ogmiosCardanoNode: ObservableCardanoNode;
 
@@ -119,9 +129,11 @@ describe('resuming projection when intersection is not local tip', () => {
   const project = (
     cardanoNode: ObservableCardanoNode,
     buffer: StabilityWindowBuffer,
+    projectedTip$: Observable<TipOrOrigin>,
     into: ProjectionOperator<Mappers.WithStakeKeys>
   ) =>
-    Bootstrap.fromCardanoNode({ blocksBufferLength: 10, buffer, cardanoNode, logger }).pipe(
+    Bootstrap.fromCardanoNode({ blocksBufferLength: 10, buffer, cardanoNode, logger, projectedTip$ }).pipe(
+      fakeTip,
       Mappers.withCertificates(),
       Mappers.withStakeKeys(),
       into,
@@ -130,13 +142,14 @@ describe('resuming projection when intersection is not local tip', () => {
 
   const testRollbackAndContinue = (
     buffer: StabilityWindowBuffer,
+    tip$: Observable<TipOrOrigin>,
     into: ProjectionOperator<Mappers.WithStakeKeys>,
     getNumberOfLocalStakeKeys: () => Promise<number>
   ) => {
     it('rolls back local data to intersection and resumes projection from there', async () => {
       // Project some events until we find at least 1 stake key registration
       const firstEventWithKeyRegistrations = await firstValueFrom(
-        project(ogmiosCardanoNode, buffer, into).pipe(filter((evt) => evt.stakeKeys.insert.length > 0))
+        project(ogmiosCardanoNode, buffer, tip$, into).pipe(filter((evt) => evt.stakeKeys.insert.length > 0))
       );
       const lastEventFromOriginalSync = firstEventWithKeyRegistrations;
       const numStakeKeysBeforeFork = await getNumberOfLocalStakeKeys();
@@ -144,13 +157,13 @@ describe('resuming projection when intersection is not local tip', () => {
 
       // Simulate a fork by adding some blocks that are not on the ogmios chain
       const stubForkCardanoNode = createForkProjectionSource(ogmiosCardanoNode, lastEventFromOriginalSync);
-      await lastValueFrom(project(stubForkCardanoNode, buffer, into).pipe(take(4)));
+      await lastValueFrom(project(stubForkCardanoNode, buffer, tip$, into).pipe(take(4)));
       const numStakeKeysAfterFork = await getNumberOfLocalStakeKeys();
       expect(numStakeKeysAfterFork).toBeGreaterThan(numStakeKeysBeforeFork);
 
       // Continue projection from ogmios
       const eventsTilStakeKeyRollback = await firstValueFrom(
-        project(ogmiosCardanoNode, buffer, into).pipe(
+        project(ogmiosCardanoNode, buffer, tip$, into).pipe(
           takeWhile((evt) => evt.stakeKeys.del.length === 0 && evt.stakeKeys.insert.length === 0, true),
           toArray()
         )
@@ -168,7 +181,7 @@ describe('resuming projection when intersection is not local tip', () => {
 
       // Continue projection from ogmios
       const firstRollForwardEvent = await lastValueFrom(
-        project(ogmiosCardanoNode, buffer, into).pipe(
+        project(ogmiosCardanoNode, buffer, tip$, into).pipe(
           takeWhile((evt) => evt.eventType === ChainSyncEventType.RollBackward, true)
         )
       );
@@ -183,20 +196,29 @@ describe('resuming projection when intersection is not local tip', () => {
     const buffer = new InMemory.InMemoryStabilityWindowBuffer();
     testRollbackAndContinue(
       buffer,
+      buffer.tip$,
       (evt$) => evt$.pipe(withStaticContext({ store }), InMemory.storeStakeKeys(), buffer.handleEvents()),
       async () => store.stakeKeys.size
     );
   });
 
   describe('typeorm', () => {
-    const buffer = new Postgres.TypeormStabilityWindowBuffer({ logger });
+    const reconnectionConfig: ReconnectionConfig = { initialInterval: 10 };
+    const entities = [BlockEntity, BlockDataEntity, StakeKeyEntity];
+    const connection$ = Postgres.createObservableConnection({
+      connectionConfig$: of(pgConnectionConfig),
+      entities,
+      logger
+    });
+    const buffer = new Postgres.TypeormStabilityWindowBuffer({ connection$, logger, reconnectionConfig });
+    const tipTracker = Postgres.createTypeormTipTracker({ connection$, reconnectionConfig });
     const dataSource = Postgres.createDataSource({
       connectionConfig: pgConnectionConfig,
       devOptions: {
         dropSchema: true,
         synchronize: true
       },
-      entities: [BlockEntity, BlockDataEntity, StakeKeyEntity],
+      entities,
       logger,
       options: {
         installExtensions: true
@@ -217,19 +239,24 @@ describe('resuming projection when intersection is not local tip', () => {
         }
       });
       await dataSource.initialize();
-      await buffer.initialize(dataSource.createQueryRunner());
     });
-    afterAll(() => dataSource.destroy());
+
+    afterAll(async () => {
+      await dataSource.destroy();
+      tipTracker.shutdown();
+    });
 
     testRollbackAndContinue(
       buffer,
+      tipTracker.tip$,
       (evt$) =>
         evt$.pipe(
-          Postgres.withTypeormTransaction({ dataSource$: of(dataSource), logger }),
+          Postgres.withTypeormTransaction({ connection$ }),
           Postgres.storeBlock(),
           Postgres.storeStakeKeys(),
           buffer.storeBlockData(),
-          Postgres.typeormTransactionCommit()
+          Postgres.typeormTransactionCommit(),
+          tipTracker.trackProjectedTip()
         ),
       getNumberOfLocalStakeKeys
     );

package/test/projection/single-tenant-utxo.test.ts

@@ -6,10 +6,20 @@ import { ConnectionConfig } from '@cardano-ogmios/client';
 import { DataSource, QueryRunner } from 'typeorm';
 import { Observable, filter, firstValueFrom, lastValueFrom, of, scan, takeWhile } from 'rxjs';
 import { OgmiosObservableCardanoNode } from '@cardano-sdk/ogmios';
+import { ReconnectionConfig } from '@cardano-sdk/util-rxjs';
 import { createDatabase, dropDatabase } from 'typeorm-extension';
 import { getEnv } from '../../src';
 import { logger } from '@cardano-sdk/util-dev';
 
+const entities = [
+  Postgres.BlockEntity,
+  Postgres.BlockDataEntity,
+  Postgres.AssetEntity,
+  Postgres.TokensEntity,
+  Postgres.OutputEntity,
+  Postgres.NftMetadataEntity
+];
+
 const ogmiosConnectionConfig = ((): ConnectionConfig => {
   const { OGMIOS_URL } = getEnv(['OGMIOS_URL']);
   const url = new URL(OGMIOS_URL);
@@ -42,14 +52,7 @@ const createDataSource = () =>
       dropSchema: true,
       synchronize: true
     },
-    entities: [
-      Postgres.BlockEntity,
-      Postgres.BlockDataEntity,
-      Postgres.AssetEntity,
-      Postgres.TokensEntity,
-      Postgres.OutputEntity,
-      Postgres.NftMetadataEntity
-    ],
+    entities,
     logger,
     options: {
       installExtensions: true
@@ -72,25 +75,32 @@ const countUniqueOutputAddresses = (queryRunner: QueryRunner) =>
     .getRawMany()
     .then((results) => results.length);
 
-describe('single-tenant utxo projection', () => {
+describe.skip('single-tenant utxo projection', () => {
   let cardanoNode: ObservableCardanoNode;
+  let connection$: Observable<Postgres.TypeormConnection>;
   let buffer: Postgres.TypeormStabilityWindowBuffer;
+  let tipTracker: Postgres.TypeormTipTracker;
   let queryRunner: QueryRunner;
   let dataSource: DataSource;
 
   const initialize = async () => {
-    buffer = new Postgres.TypeormStabilityWindowBuffer({ logger });
     await createDatabase(databaseOptions);
     dataSource = createDataSource();
     await dataSource.initialize();
     queryRunner = dataSource.createQueryRunner('slave');
-    await buffer.initialize(queryRunner);
+    connection$ = Postgres.createObservableConnection({
+      connectionConfig$: of(pgConnectionConfig),
+      entities,
+      logger
+    });
+    const reconnectionConfig: ReconnectionConfig = { initialInterval: 10 };
+    buffer = new Postgres.TypeormStabilityWindowBuffer({ connection$, logger, reconnectionConfig });
+    tipTracker = Postgres.createTypeormTipTracker({ connection$, reconnectionConfig });
   };
 
   const cleanup = async () => {
     await queryRunner.release();
     await dataSource.destroy();
-    buffer.shutdown();
   };
 
   beforeEach(async () => {
@@ -100,22 +110,9 @@ describe('single-tenant utxo projection', () => {
 
   afterEach(async () => cleanup());
 
-  const projectMultiTenant = () =>
-    Bootstrap.fromCardanoNode({ blocksBufferLength: 10, buffer, cardanoNode, logger }).pipe(
-      Mappers.withMint(),
-      Mappers.withUtxo(),
-      Postgres.withTypeormTransaction({ dataSource$: of(dataSource), logger }),
-      Postgres.storeBlock(),
-      Postgres.storeAssets(),
-      Postgres.storeUtxo(),
-      buffer.storeBlockData(),
-      Postgres.typeormTransactionCommit(),
-      requestNext()
-    );
-
   const storeUtxo = (evt$: Observable<ProjectionEvent<Mappers.WithMint & Mappers.WithUtxo>>) =>
     evt$.pipe(
-      Postgres.withTypeormTransaction({ dataSource$: of(dataSource), logger }),
+      Postgres.withTypeormTransaction({ connection$ }),
       Postgres.storeBlock(),
       Postgres.storeAssets(),
       Postgres.storeUtxo(),
@@ -123,12 +120,28 @@ describe('single-tenant utxo projection', () => {
       Postgres.typeormTransactionCommit()
     );
 
+  const projectMultiTenant = () =>
+    Bootstrap.fromCardanoNode({
+      blocksBufferLength: 10,
+      buffer,
+      cardanoNode,
+      logger,
+      projectedTip$: tipTracker.tip$
+    }).pipe(Mappers.withMint(), Mappers.withUtxo(), storeUtxo, requestNext(), tipTracker.trackProjectedTip());
+
   const projectSingleTenant = (addresses: Cardano.PaymentAddress[]) =>
-    Bootstrap.fromCardanoNode({ blocksBufferLength: 10, buffer, cardanoNode, logger }).pipe(
+    Bootstrap.fromCardanoNode({
+      blocksBufferLength: 10,
+      buffer,
+      cardanoNode,
+      logger,
+      projectedTip$: tipTracker.tip$
+    }).pipe(
       Mappers.withMint(),
       Mappers.withUtxo(),
       Mappers.filterProducedUtxoByAddresses({ addresses }),
       storeUtxo,
+      tipTracker.trackProjectedTip(),
       requestNext()
     );