@cardano-sdk/e2e 0.36.7 → 0.36.9

package/docker-compose.yml

@@ -111,6 +111,11 @@ services:
       METADATA_JOB_RETRY_DELAY: 60
       POOLS_METRICS_INTERVAL: 50
 
+  ws-server:
+    volumes:
+      - ./local-network/config/network:/config
+      - sdk-ipc:/sdk-ipc
+
 volumes:
   sdk-ipc:
     driver: local

package/jest.config.js

@@ -34,6 +34,7 @@ module.exports = {
     project('providers'),
     project('wallet_epoch_0'),
     project('wallet_epoch_3'),
+    project('ws-server'),
     {
       ...commonProjectProps,
       displayName: 'wallet-real-ada',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.36.7",
+  "version": "0.36.9",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "engines": {
     "node": ">=16.20.2"
@@ -31,7 +31,7 @@
     "test:ogmios": "jest -c jest.config.js --forceExit --selectProjects ogmios --runInBand --verbose",
     "test:pg-boss": "jest -c jest.config.js --forceExit --selectProjects pg-boss --runInBand --verbose",
     "test:providers": "jest -c jest.config.js --forceExit --selectProjects providers --runInBand --verbose",
-    "test:wallet": "yarn wait-for-network-init ; yarn test:wallet:epoch0 && { yarn wait-for-network-epoch-3 ; yarn test:wallet:epoch3 ; }",
+    "test:wallet": "yarn wait-for-network-init ; yarn test:wallet:epoch0 && yarn test:ws && { yarn wait-for-network-epoch-3 ; yarn test:wallet:epoch3 ; }",
     "test:wallet:epoch0": "jest -c jest.config.js --forceExit --selectProjects wallet_epoch_0 --runInBand --verbose",
     "test:wallet:epoch3": "jest -c jest.config.js --forceExit --selectProjects wallet_epoch_3 --runInBand --verbose",
     "test:wallet-real-ada": "NETWORK_SPEED=slow jest -c jest.config.js --forceExit --selectProjects wallet-real-ada --runInBand --verbose",
@@ -46,8 +46,10 @@
     "test:web-extension:watch:run": "yarn test:web-extension:run --watch",
     "test:web-extension:watch": "run-s test:web-extension:build test:web-extension:watch:bg",
     "test:web-extension:watch:bg": "run-p test:web-extension:watch:build test:web-extension:watch:run",
+    "test:ws": "jest -c jest.config.js --forceExit --selectProjects ws-server --runInBand --verbose",
     "local-network:common": "PRE_CONWAY=${PRE_CONWAY:-stable} DISABLE_DB_CACHE=${DISABLE_DB_CACHE:-true} SUBMIT_API_ARGS='--testnet-magic 888' USE_BLOCKFROST=false __FIX_UMASK__=$(chmod -R a+r ../../compose/placeholder-secrets) docker compose --env-file ../cardano-services/environments/.env.local -p local-network-e2e -f docker-compose.yml -f ../../compose/common.yml -f ../../compose/$(uname -m).yml $FILES up",
     "local-network:up": "FILES='' yarn local-network:common",
+    "local-network:single:up": "FILES='' yarn local-network:common cardano-node file-server local-testnet ogmios postgres",
     "local-network:profile:up": "FILES='-f ../../compose/pg-agent.yml' yarn local-network:common",
     "local-network:down": "docker compose -p local-network-e2e -f docker-compose.yml -f ../../compose/common.yml -f ../../compose/pg-agent.yml down -v --remove-orphans",
     "cardano-services:up": "ts-node --transpile-only ../cardano-services/src/cli.ts start-provider-server",
@@ -79,20 +81,20 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^7.1.2",
     "@cardano-ogmios/client": "6.3.0",
-    "@cardano-sdk/cardano-services": "~0.28.12",
-    "@cardano-sdk/cardano-services-client": "~0.19.12",
-    "@cardano-sdk/core": "~0.35.2",
-    "@cardano-sdk/crypto": "~0.1.26",
-    "@cardano-sdk/hardware-ledger": "~0.9.13",
-    "@cardano-sdk/hardware-trezor": "~0.4.33",
-    "@cardano-sdk/input-selection": "~0.13.6",
-    "@cardano-sdk/key-management": "~0.20.11",
-    "@cardano-sdk/ogmios": "~0.15.33",
-    "@cardano-sdk/tx-construction": "~0.19.6",
-    "@cardano-sdk/util": "~0.15.3",
-    "@cardano-sdk/util-dev": "~0.21.6",
-    "@cardano-sdk/util-rxjs": "~0.7.19",
-    "@cardano-sdk/wallet": "~0.38.7",
+    "@cardano-sdk/cardano-services": "~0.28.14",
+    "@cardano-sdk/cardano-services-client": "~0.19.14",
+    "@cardano-sdk/core": "~0.35.4",
+    "@cardano-sdk/crypto": "~0.1.28",
+    "@cardano-sdk/hardware-ledger": "~0.10.1",
+    "@cardano-sdk/hardware-trezor": "~0.4.35",
+    "@cardano-sdk/input-selection": "~0.13.8",
+    "@cardano-sdk/key-management": "~0.21.1",
+    "@cardano-sdk/ogmios": "~0.15.35",
+    "@cardano-sdk/tx-construction": "~0.19.8",
+    "@cardano-sdk/util": "~0.15.4",
+    "@cardano-sdk/util-dev": "~0.21.8",
+    "@cardano-sdk/util-rxjs": "~0.7.21",
+    "@cardano-sdk/wallet": "~0.39.1",
     "@dcspark/cardano-multiplatform-lib-nodejs": "^3.1.1",
     "@vespaiach/axios-fetch-adapter": "^0.3.0",
     "axios": "^0.28.0",
@@ -122,10 +124,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.12.24",
-    "@cardano-sdk/projection": "~0.11.23",
-    "@cardano-sdk/projection-typeorm": "~0.8.25",
-    "@cardano-sdk/web-extension": "~0.29.7",
+    "@cardano-sdk/dapp-connector": "~0.12.26",
+    "@cardano-sdk/projection": "~0.11.25",
+    "@cardano-sdk/projection-typeorm": "~0.8.27",
+    "@cardano-sdk/web-extension": "~0.29.9",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -179,5 +181,5 @@
     "webpack-cli": "^4.9.2",
     "webpack-merge": "^5.8.0"
   },
-  "gitHead": "271f2e3658294b247f15467ae863d66784a41228"
+  "gitHead": "8251245efc792b61a6a5c2be4b42fcbaeaf2312a"
 }

package/src/environment.ts

@@ -109,7 +109,8 @@ const validators = {
   VIRTUAL_USERS_COUNT: num(),
   VIRTUAL_USERS_GENERATE_DURATION: num(),
   WALLET_SYNC_TIMEOUT_IN_MS: num({ default: undefined }),
-  WORKER_PARALLEL_TRANSACTION: num()
+  WORKER_PARALLEL_TRANSACTION: num(),
+  WS_PROVIDER_URL: str()
 } as const;
 
 type Entries<T> = { [K in keyof T]: [K, T[K]] }[keyof T][];
@@ -159,6 +160,7 @@ export const walletVariables = [
   'TX_SUBMIT_PROVIDER_PARAMS',
   'UTXO_PROVIDER',
   'UTXO_PROVIDER_PARAMS',
+  'WS_PROVIDER_URL',
   'ADDRESS_DISCOVERY',
   'NETWORK_SPEED'
 ] as const;

package/src/factories.ts

@@ -34,12 +34,8 @@ import {
   Witnesser,
   util
 } from '@cardano-sdk/key-management';
-import { LedgerKeyAgent } from '@cardano-sdk/hardware-ledger';
-import { Logger } from 'ts-log';
-import { NodeTxSubmitProvider } from '@cardano-sdk/cardano-services';
-import { OgmiosObservableCardanoNode } from '@cardano-sdk/ogmios';
-import { TrezorKeyAgent } from '@cardano-sdk/hardware-trezor';
 import {
+  CardanoWsClient,
   assetInfoHttpProvider,
   chainHistoryHttpProvider,
   handleHttpProvider,
@@ -49,8 +45,14 @@ import {
   txSubmitHttpProvider,
   utxoHttpProvider
 } from '@cardano-sdk/cardano-services-client';
+import { LedgerKeyAgent } from '@cardano-sdk/hardware-ledger';
+import { Logger } from 'ts-log';
+import { NodeTxSubmitProvider } from '@cardano-sdk/cardano-services';
+import { OgmiosObservableCardanoNode } from '@cardano-sdk/ogmios';
+import { TrezorKeyAgent } from '@cardano-sdk/hardware-trezor';
 import { createStubStakePoolProvider } from '@cardano-sdk/util-dev';
 import { filter, firstValueFrom, of } from 'rxjs';
+import { getEnv, walletVariables } from './environment';
 import DeviceConnection from '@cardano-foundation/ledgerjs-hw-app-cardano';
 import memoize from 'lodash/memoize.js';
 
@@ -63,6 +65,7 @@ const HTTP_PROVIDER = 'http';
 const OGMIOS_PROVIDER = 'ogmios';
 const STUB_PROVIDER = 'stub';
 const MISSING_URL_PARAM = 'Missing URL';
+const WS_PROVIDER = 'ws';
 
 export type CreateKeyAgent = (dependencies: KeyAgentDependencies) => Promise<AsyncKeyAgent>;
 export const keyManagementFactory = new ProviderFactory<CreateKeyAgent>();
@@ -128,6 +131,16 @@ networkInfoProviderFactory.register(
   }
 );
 
+networkInfoProviderFactory.register(WS_PROVIDER, (_params: any, logger: Logger): Promise<NetworkInfoProvider> => {
+  const env = getEnv(walletVariables);
+
+  if (env.WS_PROVIDER_URL === undefined) throw new Error(`${networkInfoHttpProvider.name}: ${MISSING_URL_PARAM}`);
+
+  const wsClient = new CardanoWsClient({ logger }, { url: new URL(env.WS_PROVIDER_URL) });
+
+  return Promise.resolve(wsClient.networkInfoProvider);
+});
+
 rewardsProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<RewardsProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${rewardsHttpProvider.name}: ${MISSING_URL_PARAM}`);
 

package/test/k6/scenarios/web-socket.test.js

@@ -0,0 +1,70 @@
+// cSpell:ignore loadimpact
+
+import { Counter, Trend } from 'k6/metrics';
+import { check } from 'k6';
+import ws from 'k6/ws';
+
+// eslint-disable-next-line no-undef
+const { TARGET_ENV, TARGET_NET, URL, WALLETS } = Object.assign({ WALLETS: '10000' }, __ENV);
+const url = TARGET_ENV ? `wss://${TARGET_ENV}-${TARGET_NET}${TARGET_ENV === 'ops' ? '-1' : ''}.lw.iog.io/ws` : URL;
+
+if (TARGET_ENV && !['dev', 'ops', 'staging', 'prod'].includes(TARGET_ENV))
+  throw new Error(`Not valid TARGET_ENV: ${TARGET_ENV}`);
+if (TARGET_NET && !['preview', 'preprod', 'sanchonet', 'mainnet'].includes(TARGET_NET))
+  throw new Error(`Not valid TARGET_NET: ${TARGET_NET}`);
+if (!(TARGET_ENV && TARGET_NET) && !URL) throw new Error('Please specify both TARGET_ENV and TARGET_NET or URL');
+
+export const options = {
+  ext: {
+    loadimpact: {
+      apm: [],
+      distribution: { 'amazon:us:portland': { loadZone: 'amazon:us:portland', percent: 100 } }
+    }
+  },
+  scenarios: {
+    connections: {
+      executor: 'ramping-vus',
+      gracefulRampDown: '0s',
+      gracefulStop: '120s',
+      stages: [{ duration: '3s', target: Number.parseInt(WALLETS, 10) }],
+      startVUs: 10
+    }
+  }
+};
+
+const operationalTrend = new Trend('_operational', true);
+const unexpectedCloseCounter = new Counter('_unexpected_close');
+
+export const run = () => {
+  const begin = Date.now();
+
+  const res = ws.connect(url, null, (socket) => {
+    let closed = false;
+    let firstMessage = true;
+
+    socket.on('message', () => {
+      if (firstMessage) {
+        operationalTrend.add(Date.now() - begin);
+        firstMessage = false;
+      }
+    });
+
+    // Count unexpected close
+    socket.on('close', () => {
+      if (!closed) unexpectedCloseCounter.add(1);
+    });
+
+    // Heartbeat
+    socket.setTimeout(() => socket.send('{}'), 30 * 1000);
+
+    // End the test after 80"
+    socket.setTimeout(() => {
+      closed = true;
+      socket.close();
+    }, 80 * 1000);
+  });
+
+  check(res, { 'status is 101': (r) => r && r.status === 101 });
+};
+
+export default run;

package/test/long-running/webSocket.test.ts

@@ -0,0 +1,25 @@
+import { CardanoWsClient } from '@cardano-sdk/cardano-services-client';
+import { getEnv, walletVariables } from '../../src';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv([...walletVariables]);
+
+describe('Web Socket', () => {
+  let client: CardanoWsClient;
+
+  const openClient = () => (client = new CardanoWsClient({ logger }, { url: new URL(env.WS_PROVIDER_URL) }));
+
+  const closeClient = () => (client ? client.close() : Promise.resolve());
+
+  afterEach(closeClient);
+
+  it('CardanoWsClient.epoch$ emits on epoch rollover', (done) => {
+    openClient();
+
+    // If it emits on epoch rollover ok, otherwise the test fails on timeout
+    const subscription = client.epoch$.subscribe(() => {
+      subscription.unsubscribe();
+      done();
+    });
+  });
+});

package/test/ws-server/webSocket.test.ts

@@ -0,0 +1,220 @@
+import { CardanoWsClient } from '@cardano-sdk/cardano-services-client';
+import {
+  CardanoWsServer,
+  GenesisData,
+  createDnsResolver,
+  getOgmiosCardanoNode,
+  util
+} from '@cardano-sdk/cardano-services';
+import { HealthCheckResponse, WsProvider } from '@cardano-sdk/core';
+import { OgmiosCardanoNode } from '@cardano-sdk/ogmios';
+import { Pool } from 'pg';
+import { filter, firstValueFrom } from 'rxjs';
+import { getEnv, walletVariables } from '../../src';
+import { getPort } from 'get-port-please';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv([...walletVariables, 'DB_SYNC_CONNECTION_STRING', 'OGMIOS_URL']);
+
+const wsProviderReady = (provider: WsProvider) =>
+  new Promise<void>((resolve, reject) => {
+    // eslint-disable-next-line prefer-const
+    let timeout: NodeJS.Timeout | undefined;
+
+    const subscription = provider.health$.subscribe(({ ok }) => {
+      if (ok) {
+        if (timeout) clearTimeout(timeout);
+        subscription.unsubscribe();
+        resolve();
+      }
+    });
+
+    timeout = setTimeout(() => {
+      subscription.unsubscribe();
+      reject(new Error('WsProvider timeout'));
+    }, 10_000);
+
+    timeout.unref();
+  });
+
+const wsProviderReadyAgain = (provider: WsProvider, close: () => Promise<unknown>) =>
+  new Promise<void>(async (resolve, reject) => {
+    const oks: boolean[] = [];
+    let closed = false;
+    // eslint-disable-next-line prefer-const
+    let timeout: NodeJS.Timeout | undefined;
+
+    const subscription = provider.health$.subscribe(({ ok }) => {
+      oks.push(ok);
+
+      if (closed && ok) {
+        if (timeout) clearTimeout(timeout);
+        subscription.unsubscribe();
+
+        try {
+          const [, ...last] = oks;
+
+          // The first emitted event is the ok buffered one
+          // next we expect at least one not ok event i.e. the close function had the desired effect
+          // last we expect one more ok event when provider is operational once again
+          expect(oks.length).toBeGreaterThanOrEqual(3);
+          expect(oks[0]).toBeTruthy();
+          expect(oks[1]).toBeFalsy();
+          expect(last.some((result) => result));
+
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      }
+    });
+
+    try {
+      await close();
+    } catch (error) {
+      reject(error);
+    }
+
+    closed = true;
+
+    timeout = setTimeout(() => {
+      subscription.unsubscribe();
+      reject(new Error('WsProvider timeout'));
+    }, 10_000);
+
+    timeout.unref();
+  });
+
+describe('Web Socket', () => {
+  let db: Pool;
+  let cardanoNode: OgmiosCardanoNode;
+  let genesisData: GenesisData;
+  let port: number;
+
+  let client: CardanoWsClient;
+  let server: CardanoWsServer;
+
+  const openClient = (heartbeatInterval = 55) =>
+    (client = new CardanoWsClient({ logger }, { heartbeatInterval, url: new URL(`ws://localhost:${port}/ws`) }));
+
+  const openServer = (heartbeatTimeout = 60) =>
+    (server = new CardanoWsServer(
+      { cardanoNode, db, genesisData, logger },
+      { dbCacheTtl: 120, heartbeatTimeout, port }
+    ));
+
+  const closeClient = () => (client ? client.close() : Promise.resolve());
+  const closeServer = () => (server ? new Promise<void>((resolve) => server.close(resolve)) : Promise.resolve());
+
+  const listenToClientHealthFor15Seconds = async () => {
+    const health: HealthCheckResponse[] = [];
+    const subscription = client.health$.subscribe((value) => health.push(value));
+
+    // Listen on client.health$ for 15"
+    await new Promise((resolve) => setTimeout(resolve, 15_000));
+
+    subscription.unsubscribe();
+
+    return health;
+  };
+
+  beforeAll(async () => {
+    const dnsResolver = createDnsResolver({ factor: 1.1, maxRetryTime: 1000 }, logger);
+
+    cardanoNode = await getOgmiosCardanoNode(dnsResolver, logger, { ogmiosUrl: new URL(env.OGMIOS_URL) });
+    db = new Pool({ connectionString: env.DB_SYNC_CONNECTION_STRING });
+    genesisData = await util.loadGenesisData('local-network/config/network/cardano-node/config.json');
+    port = await getPort();
+
+    await cardanoNode.initialize();
+    await cardanoNode.start();
+  });
+
+  afterAll(() => Promise.all([cardanoNode.shutdown(), db.end()]));
+
+  afterEach(() => Promise.all([closeClient(), closeServer()]));
+
+  it('Server can re-connect to DB if NOTIFY connection drops', async () => {
+    // Close server db connection from DB server side
+    const query =
+      "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid <> pg_backend_pid() AND query = 'LISTEN sdk_tip'";
+
+    openServer();
+    await wsProviderReady(server);
+
+    await wsProviderReadyAgain(server, () => db.query(query));
+  });
+
+  it('Client can re-connect to server if web socket connection drops', async () => {
+    openServer();
+    await wsProviderReady(server);
+
+    openClient();
+    await wsProviderReady(client);
+
+    await wsProviderReadyAgain(client, async () => {
+      // Close the server and open a new one
+      await closeServer();
+      openServer();
+    });
+  });
+
+  it('Server disconnects clients on heartbeat timeout', async () => {
+    // Open a server with 3" heartbeat timeout
+    openServer(3);
+    await wsProviderReady(server);
+
+    openClient();
+    await wsProviderReady(client);
+
+    const health = await listenToClientHealthFor15Seconds();
+
+    // Considering the server performs timeouts check every 10"
+    // We expect the heath state of the client goes up and down more time
+    expect(health.length).toBeGreaterThanOrEqual(3);
+    // We expect the heath state of the client goes up at least twice
+    expect(health.filter(({ ok }) => ok).length).toBeGreaterThanOrEqual(2);
+    // We expect the heath state of the client goes down at least once
+    expect(health.some(({ ok }) => !ok)).toBeTruthy();
+  });
+
+  it("Server doesn't disconnects clients without heartbeat timeouts", async () => {
+    // Open a server with 3" heartbeat timeout
+    openServer(3);
+    await wsProviderReady(server);
+
+    // Open a client with 2" heartbeat interval
+    openClient(2);
+    await wsProviderReady(client);
+
+    const health = await listenToClientHealthFor15Seconds();
+
+    // We expect only the buffered ok heath state
+    expect(health.length).toBe(1);
+    expect(health[0].ok).toBeTruthy();
+  });
+
+  describe('CardanoWsClient.networkInfoProvider', () => {
+    it('It throws when disconnected but when starting', async () => {
+      openServer();
+      await wsProviderReady(server);
+
+      openClient();
+
+      // This test doesn't calls wsProviderReady(client)
+      // to check the provider doesn't throw if called before its init sequence completed
+      await expect(client.networkInfoProvider.ledgerTip()).resolves.toHaveProperty('blockNo');
+
+      await closeServer();
+      await firstValueFrom(client.health$.pipe(filter(({ ok }) => !ok)));
+
+      await expect(client.networkInfoProvider.ledgerTip()).rejects.toThrowError('CONNECTION_FAILURE');
+    });
+
+    it('If called when still starting, it throws on connect error', async () => {
+      openClient();
+
+      await expect(client.networkInfoProvider.ledgerTip()).rejects.toThrowError('CONNECTION_FAILURE');
+    });
+  });
+});