@cardano-sdk/e2e 0.23.0 → 0.25.0

package/docker-compose.yml

@@ -79,6 +79,13 @@ services:
       - ./local-network/config/network:/config
       - sdk-ipc:/sdk-ipc
 
+  asset-provider-server:
+    environment:
+      HANDLE_POLICY_IDS_FILE: /sdk-ipc/handle_policy_ids
+    volumes:
+      - ./local-network/config/network:/config
+      - sdk-ipc:/sdk-ipc
+
 volumes:
   sdk-ipc:
     driver: local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "engines": {
     "node": ">=16.20.2"
@@ -81,19 +81,20 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^6.0.0",
     "@cardano-ogmios/client": "5.6.0",
-    "@cardano-sdk/cardano-services": "~0.21.0",
-    "@cardano-sdk/cardano-services-client": "~0.14.2",
+    "@cardano-sdk/cardano-services": "~0.22.0",
+    "@cardano-sdk/cardano-services-client": "~0.14.4",
     "@cardano-sdk/core": "~0.21.0",
     "@cardano-sdk/crypto": "~0.1.15",
-    "@cardano-sdk/hardware-ledger": "~0.5.0",
-    "@cardano-sdk/input-selection": "~0.12.2",
-    "@cardano-sdk/key-management": "~0.13.0",
-    "@cardano-sdk/ogmios": "~0.13.2",
-    "@cardano-sdk/tx-construction": "~0.14.0",
+    "@cardano-sdk/hardware-ledger": "~0.6.1",
+    "@cardano-sdk/hardware-trezor": "~0.2.1",
+    "@cardano-sdk/input-selection": "~0.12.4",
+    "@cardano-sdk/key-management": "~0.14.0",
+    "@cardano-sdk/ogmios": "~0.14.0",
+    "@cardano-sdk/tx-construction": "~0.14.2",
     "@cardano-sdk/util": "~0.14.2",
-    "@cardano-sdk/util-dev": "~0.17.1",
-    "@cardano-sdk/util-rxjs": "~0.5.13",
-    "@cardano-sdk/wallet": "~0.24.0",
+    "@cardano-sdk/util-dev": "~0.17.3",
+    "@cardano-sdk/util-rxjs": "~0.6.0",
+    "@cardano-sdk/wallet": "~0.25.1",
     "@dcspark/cardano-multiplatform-lib-nodejs": "^3.1.1",
     "@vespaiach/axios-fetch-adapter": "^0.3.0",
     "axios": "^0.27.2",
@@ -124,9 +125,9 @@
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
     "@cardano-sdk/dapp-connector": "~0.11.1",
-    "@cardano-sdk/projection": "~0.8.2",
-    "@cardano-sdk/projection-typeorm": "~0.5.2",
-    "@cardano-sdk/web-extension": "~0.16.1",
+    "@cardano-sdk/projection": "~0.9.0",
+    "@cardano-sdk/projection-typeorm": "~0.6.0",
+    "@cardano-sdk/web-extension": "~0.16.3",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -179,5 +180,5 @@
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
-  "gitHead": "02bec948d91c1f501dc992289523083179d78b06"
+  "gitHead": "9461bf68e287a90c964ed982a562b8fc09edabc8"
 }

package/src/factories.ts

@@ -30,7 +30,6 @@ import {
   CommunicationType,
   InMemoryKeyAgent,
   KeyAgentDependencies,
-  TrezorKeyAgent,
   util
 } from '@cardano-sdk/key-management';
 import {
@@ -47,6 +46,7 @@ import {
 import { LedgerKeyAgent } from '@cardano-sdk/hardware-ledger';
 import { Logger } from 'ts-log';
 import { OgmiosTxSubmitProvider } from '@cardano-sdk/ogmios';
+import { TrezorKeyAgent } from '@cardano-sdk/hardware-trezor';
 import { createConnectionObject } from '@cardano-ogmios/client';
 import { createStubStakePoolProvider } from '@cardano-sdk/util-dev';
 import { filter, firstValueFrom } from 'rxjs';

package/src/tsconfig.json

@@ -33,6 +33,9 @@
     },
     {
       "path": "../../hardware-ledger/src"
+    },
+    {
+      "path": "../../hardware-trezor/src"
     }
   ]
 }

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,12 +17,14 @@ 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';
 
@@ -109,6 +111,14 @@ const createForkProjectionSource = (
   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
@@ -74,23 +77,30 @@ const countUniqueOutputAddresses = (queryRunner: QueryRunner) =>
 
 describe('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()
     );
 

package/test/tsconfig.json

@@ -26,6 +26,9 @@
     {
       "path": "../../util-dev/src"
     },
+    {
+      "path": "../../util-rxjs/src"
+    },
     {
       "path": "../../wallet/src"
     },