@cardano-sdk/e2e 0.45.3 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.45.3",
+  "version": "0.46.0",
   "description": "End to end tests for the cardano-js-sdk packages.",
   "repository": "https://github.com/input-output-hk/cardano-js-sdk",
   "license": "Apache-2.0",
@@ -23,7 +23,6 @@
     "load-test-custom:wallet-restoration": "ts-node test/load-test-custom/wallet-restoration/wallet-restoration.test.ts",
     "test": "echo 'test' command not implemented yet",
     "test:blockfrost": "jest -c jest.config.js --forceExit --selectProjects blockfrost --runInBand --verbose",
-    "test:blockfrost:providers": "jest -c jest.config.js --forceExit --selectProjects blockfrost-providers --runInBand --verbose",
     "test:utils": "jest -c jest.config.js --forceExit --selectProjects utils --verbose",
     "test:long-running": "jest -c jest.config.js --forceExit --selectProjects long-running --runInBand --verbose",
     "test:local-network": "jest -c jest.config.js --forceExit --selectProjects local-network --runInBand --verbose",
@@ -76,20 +75,20 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^7.1.4",
     "@cardano-ogmios/client": "6.9.0",
-    "@cardano-sdk/cardano-services": "~0.32.3",
-    "@cardano-sdk/cardano-services-client": "~0.22.3",
-    "@cardano-sdk/core": "~0.41.4",
-    "@cardano-sdk/crypto": "~0.1.31",
-    "@cardano-sdk/hardware-ledger": "~0.12.13",
-    "@cardano-sdk/hardware-trezor": "~0.6.12",
-    "@cardano-sdk/input-selection": "~0.13.28",
-    "@cardano-sdk/key-management": "~0.24.10",
-    "@cardano-sdk/ogmios": "~0.18.13",
-    "@cardano-sdk/tx-construction": "~0.21.13",
+    "@cardano-sdk/cardano-services": "~0.33.0",
+    "@cardano-sdk/cardano-services-client": "~0.23.0",
+    "@cardano-sdk/core": "~0.41.5",
+    "@cardano-sdk/crypto": "~0.1.32",
+    "@cardano-sdk/hardware-ledger": "~0.12.14",
+    "@cardano-sdk/hardware-trezor": "~0.6.13",
+    "@cardano-sdk/input-selection": "~0.13.29",
+    "@cardano-sdk/key-management": "~0.24.11",
+    "@cardano-sdk/ogmios": "~0.18.14",
+    "@cardano-sdk/tx-construction": "~0.21.14",
     "@cardano-sdk/util": "~0.15.5",
-    "@cardano-sdk/util-dev": "~0.23.13",
-    "@cardano-sdk/util-rxjs": "~0.7.41",
-    "@cardano-sdk/wallet": "~0.44.21",
+    "@cardano-sdk/util-dev": "~0.23.14",
+    "@cardano-sdk/util-rxjs": "~0.7.42",
+    "@cardano-sdk/wallet": "~0.44.23",
     "@dcspark/cardano-multiplatform-lib-nodejs": "^3.1.1",
     "@shiroyasha9/axios-fetch-adapter": "1.0.3",
     "axios": "^1.7.4",
@@ -119,10 +118,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.12.44",
-    "@cardano-sdk/projection": "~0.12.13",
-    "@cardano-sdk/projection-typeorm": "~0.9.13",
-    "@cardano-sdk/web-extension": "~0.34.20",
+    "@cardano-sdk/dapp-connector": "~0.12.45",
+    "@cardano-sdk/projection": "~0.12.14",
+    "@cardano-sdk/projection-typeorm": "~0.9.14",
+    "@cardano-sdk/web-extension": "~0.34.22",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -182,5 +181,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0d9fa5f83b6e9cf34412eaf94cc1e4541f3b0159"
+  "gitHead": "379316d14c7774d2b7ef4ca726ed983f07568611"
 }

package/src/factories.ts

@@ -37,7 +37,12 @@ import {
 } from '@cardano-sdk/key-management';
 import {
   BlockfrostAssetProvider,
+  BlockfrostChainHistoryProvider,
   BlockfrostClient,
+  BlockfrostNetworkInfoProvider,
+  BlockfrostRewardsProvider,
+  BlockfrostTxSubmitProvider,
+  BlockfrostUtxoProvider,
   CardanoWsClient,
   assetInfoHttpProvider,
   chainHistoryHttpProvider,
@@ -162,6 +167,20 @@ chainHistoryProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).chainHistoryProvider
 );
 
+chainHistoryProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostChainHistoryProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostChainHistoryProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        await networkInfoProviderFactory.create('blockfrost', params, logger),
+        logger
+      )
+    );
+  });
+});
+
 networkInfoProviderFactory.register(
   HTTP_PROVIDER,
   async (params: any, logger: Logger): Promise<NetworkInfoProvider> => {
@@ -178,6 +197,19 @@ networkInfoProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).networkInfoProvider
 );
 
+networkInfoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostNetworkInfoProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostNetworkInfoProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 rewardsProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<RewardsProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${rewardsHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -186,6 +218,19 @@ rewardsProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logge
   });
 });
 
+rewardsProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostRewardsProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostRewardsProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 txSubmitProviderFactory.register(OGMIOS_PROVIDER, async (params: any, logger: Logger): Promise<TxSubmitProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${NodeTxSubmitProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -220,6 +265,19 @@ txSubmitProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logg
   });
 });
 
+txSubmitProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostTxSubmitProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostTxSubmitProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 utxoProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<UtxoProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${utxoHttpProvider.name}: ${MISSING_URL_PARAM}`);
 
@@ -233,6 +291,19 @@ utxoProviderFactory.register(
   async (_params: any, logger: Logger) => (await getWsClient(logger)).utxoProvider
 );
 
+utxoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) => {
+  if (params.baseUrl === undefined) throw new Error(`${BlockfrostUtxoProvider.name}: ${MISSING_URL_PARAM}`);
+
+  return new Promise(async (resolve) => {
+    resolve(
+      new BlockfrostUtxoProvider(
+        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        logger
+      )
+    );
+  });
+});
+
 handleProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger): Promise<HandleProvider> => {
   if (params.baseUrl === undefined) throw new Error(`${handleHttpProvider.name}: ${MISSING_URL_PARAM}`);
 

package/test/blockfrost/queryTransactions.test.ts

@@ -1,18 +1,13 @@
-import { BlockfrostChainHistoryProvider, BlockfrostNetworkInfoProvider, util } from '@cardano-sdk/cardano-services';
+import { BlockfrostChainHistoryProvider, BlockfrostNetworkInfoProvider } from '@cardano-sdk/cardano-services-client';
 import { Cardano, ChainHistoryProvider } from '@cardano-sdk/core';
 import { logger } from '@cardano-sdk/util-dev';
+import { util } from '@cardano-sdk/cardano-services';
 
 describe.only('BlockfrostChainHistoryProvider', () => {
   let chainHistoryProvider: ChainHistoryProvider;
-  let blockfrost;
   beforeAll(async () => {
-    blockfrost = util.getBlockfrostApi();
-    const networkInfoProvider = new BlockfrostNetworkInfoProvider({ blockfrost, logger });
-    chainHistoryProvider = new BlockfrostChainHistoryProvider({
-      blockfrost,
-      logger,
-      networkInfoProvider
-    });
+    const networkInfoProvider = new BlockfrostNetworkInfoProvider(util.getBlockfrostClient(), logger);
+    chainHistoryProvider = new BlockfrostChainHistoryProvider(util.getBlockfrostClient(), networkInfoProvider, logger);
   });
 
   describe('transactionsByHashes', () => {

package/test/wallet_epoch_0/PersonalWallet/multiAddress.test.ts

@@ -139,6 +139,7 @@ describe('PersonalWallet/multiAddress', () => {
     expect(returnAdaTxFoundInHistory.id).toEqual(returnAdaSignedTx.id);
     expect(normalizeTxBody(returnAdaTxFoundInHistory.body)).toEqual(normalizeTxBody(returnAdaSignedTx.body));
 
+    await walletReady(newWallet.wallet);
     const endingBalance = await firstValueFromTimed(newWallet.wallet.balance.utxo.total$);
     const expectedEndingBalance = 1_500_000n - returnAdaTxFoundInHistory.body.fee;
 

package/test/blockfrost-providers/networkInfo.test.ts

@@ -1,26 +0,0 @@
-// cSpell:ignore cardano utxos
-
-import { NetworkInfoProvider } from '@cardano-sdk/core';
-import { logger } from '@cardano-sdk/util-dev';
-import { networkInfoHttpProvider } from '@cardano-sdk/cardano-services-client';
-import { toSerializableObject } from '@cardano-sdk/util';
-
-// LW-11858 to enable this
-describe.skip('Web Socket', () => {
-  const legacyProvider = networkInfoHttpProvider({ baseUrl: 'http://localhost:4000/', logger });
-  const provider = networkInfoHttpProvider({ baseUrl: 'http://localhost:4001/', logger });
-
-  const methods: (keyof NetworkInfoProvider)[] = [
-    'eraSummaries',
-    'genesisParameters',
-    'lovelaceSupply',
-    'protocolParameters',
-    'stake'
-  ];
-
-  test.each(methods)('compare %s', async (method) => {
-    const [legacyResponse, response] = await Promise.all([legacyProvider[method](), provider[method]()]);
-
-    expect(toSerializableObject(response)).toEqual(toSerializableObject(legacyResponse));
-  });
-});