@cardano-sdk/e2e 0.49.5 → 0.49.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.49.5",
+  "version": "0.49.6",
   "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",
@@ -75,20 +75,20 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^7.1.4",
     "@cardano-ogmios/client": "6.9.0",
-    "@cardano-sdk/cardano-services": "~0.33.5",
-    "@cardano-sdk/cardano-services-client": "~0.23.5",
-    "@cardano-sdk/core": "~0.42.3",
+    "@cardano-sdk/cardano-services": "~0.33.6",
+    "@cardano-sdk/cardano-services-client": "~0.23.6",
+    "@cardano-sdk/core": "~0.43.0",
     "@cardano-sdk/crypto": "~0.1.32",
-    "@cardano-sdk/hardware-ledger": "~0.13.0",
-    "@cardano-sdk/hardware-trezor": "~0.6.18",
-    "@cardano-sdk/input-selection": "~0.13.33",
-    "@cardano-sdk/key-management": "~0.25.0",
-    "@cardano-sdk/ogmios": "~0.18.19",
-    "@cardano-sdk/tx-construction": "~0.24.2",
+    "@cardano-sdk/hardware-ledger": "~0.13.1",
+    "@cardano-sdk/hardware-trezor": "~0.6.19",
+    "@cardano-sdk/input-selection": "~0.13.34",
+    "@cardano-sdk/key-management": "~0.25.1",
+    "@cardano-sdk/ogmios": "~0.18.20",
+    "@cardano-sdk/tx-construction": "~0.24.3",
     "@cardano-sdk/util": "~0.15.5",
-    "@cardano-sdk/util-dev": "~0.24.4",
-    "@cardano-sdk/util-rxjs": "~0.9.1",
-    "@cardano-sdk/wallet": "~0.48.0",
+    "@cardano-sdk/util-dev": "~0.24.5",
+    "@cardano-sdk/util-rxjs": "~0.9.2",
+    "@cardano-sdk/wallet": "~0.49.0",
     "@dcspark/cardano-multiplatform-lib-nodejs": "^3.1.1",
     "@emurgo/cardano-message-signing-nodejs": "^1.0.1",
     "@shiroyasha9/axios-fetch-adapter": "1.0.3",
@@ -119,10 +119,10 @@
     "@babel/core": "^7.18.2",
     "@babel/preset-env": "^7.18.2",
     "@babel/preset-typescript": "^7.17.12",
-    "@cardano-sdk/dapp-connector": "~0.13.0",
-    "@cardano-sdk/projection": "~0.12.19",
-    "@cardano-sdk/projection-typeorm": "~0.9.19",
-    "@cardano-sdk/web-extension": "~0.37.2",
+    "@cardano-sdk/dapp-connector": "~0.13.1",
+    "@cardano-sdk/projection": "~0.12.20",
+    "@cardano-sdk/projection-typeorm": "~0.9.20",
+    "@cardano-sdk/web-extension": "~0.37.3",
     "@dcspark/cardano-multiplatform-lib-browser": "^3.1.1",
     "@emurgo/cardano-message-signing-asmjs": "^1.0.1",
     "@types/bunyan": "^1.8.8",
@@ -182,5 +182,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "babafa33aedea682bb61dc91ca93c5f38ec5d797"
+  "gitHead": "1e454e8ffaa2637307bfde7c2183ea76d0fed76d"
 }

package/src/factories.ts

@@ -60,7 +60,7 @@ import { Logger } from 'ts-log';
 import { NoCache, 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 { createStubHandleProvider, 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';
@@ -179,7 +179,10 @@ chainHistoryProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, lo
   return new Promise(async (resolve) => {
     resolve(
       new BlockfrostChainHistoryProvider(
-        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        new BlockfrostClient(
+          { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+          { rateLimiter: { schedule: (task) => task() } }
+        ),
         await networkInfoProviderFactory.create('blockfrost', params, logger),
         logger
       )
@@ -225,7 +228,10 @@ networkInfoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, log
   return new Promise(async (resolve) => {
     resolve(
       new BlockfrostNetworkInfoProvider(
-        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        new BlockfrostClient(
+          { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+          { rateLimiter: { schedule: (task) => task() } }
+        ),
         logger
       )
     );
@@ -246,7 +252,10 @@ rewardsProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger)
   return new Promise(async (resolve) => {
     resolve(
       new BlockfrostRewardsProvider(
-        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        new BlockfrostClient(
+          { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+          { rateLimiter: { schedule: (task) => task() } }
+        ),
         logger
       )
     );
@@ -293,7 +302,10 @@ txSubmitProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger
   return new Promise(async (resolve) => {
     resolve(
       new BlockfrostTxSubmitProvider(
-        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        new BlockfrostClient(
+          { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+          { rateLimiter: { schedule: (task) => task() } }
+        ),
         logger
       )
     );
@@ -319,7 +331,10 @@ utxoProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger) =>
   return new Promise(async (resolve) => {
     resolve(
       new BlockfrostUtxoProvider(
-        new BlockfrostClient({ baseUrl: params.baseUrl }, { rateLimiter: { schedule: (task) => task() } }),
+        new BlockfrostClient(
+          { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+          { rateLimiter: { schedule: (task) => task() } }
+        ),
         logger
       )
     );
@@ -334,6 +349,11 @@ handleProviderFactory.register(HTTP_PROVIDER, async (params: any, logger: Logger
   });
 });
 
+handleProviderFactory.register(
+  STUB_PROVIDER,
+  async (): Promise<HandleProvider> => Promise.resolve(createStubHandleProvider())
+);
+
 // Stake Pool providers
 stakePoolProviderFactory.register(
   STUB_PROVIDER,

package/test/providers/TxSubmitProvider.test.ts

@@ -0,0 +1,126 @@
+import { BaseWallet } from '@cardano-sdk/wallet';
+import { Cardano, ProviderFailure, TxSubmissionErrorCode, TxSubmitProvider } from '@cardano-sdk/core';
+import { GenericTxBuilder, TxBuilderDependencies } from '@cardano-sdk/tx-construction';
+import { firstValueFrom } from 'rxjs';
+import { getEnv, getWallet, walletVariables } from '../../src';
+import { logger } from '@cardano-sdk/util-dev';
+
+describe('TxSubmitProvider', () => {
+  let wallet: BaseWallet;
+  let txSubmitProvider: TxSubmitProvider;
+  let ownAddress: Cardano.PaymentAddress;
+  let walletTxBuilderDependencies: TxBuilderDependencies;
+
+  beforeAll(async () => {
+    const env = getEnv(walletVariables);
+    ({
+      wallet,
+      providers: { txSubmitProvider }
+    } = await getWallet({ env, idx: 0, logger, name: 'Test Wallet' }));
+    const addresses = await firstValueFrom(wallet.addresses$);
+    ownAddress = addresses[0].address;
+    walletTxBuilderDependencies = wallet.getTxBuilderDependencies();
+  });
+
+  it('maps ProviderError{TxSubmissionError{OutsideOfValidityInterval}}', async () => {
+    const actualTip = await firstValueFrom(wallet.tip$);
+    const txBuilder = new GenericTxBuilder({
+      ...walletTxBuilderDependencies,
+      txBuilderProviders: {
+        ...walletTxBuilderDependencies.txBuilderProviders,
+        tip: async () => ({
+          ...actualTip,
+          // GenericTxBuilder fails to build a tx with expired validity interval.
+          // we need to trick it to believe the it's within validity interval
+          // in order to test submission error
+          slot: Cardano.Slot(actualTip.slot - 10)
+        })
+      }
+    });
+    const tx = await txBuilder
+      .addOutput({ address: ownAddress, value: { coins: 2_000_000n } })
+      .setValidityInterval({ invalidHereafter: Cardano.Slot(actualTip.slot - 1) })
+      .build()
+      .sign();
+
+    await expect(txSubmitProvider.submitTx({ signedTransaction: tx.cbor })).rejects.toThrow(
+      expect.objectContaining({
+        innerError: expect.objectContaining({
+          code: TxSubmissionErrorCode.OutsideOfValidityInterval
+        }),
+        reason: ProviderFailure.BadRequest
+      })
+    );
+  });
+
+  it('maps ProviderError{TxSubmissionError{ValueNotConserved}}', async () => {
+    const txBuilder = new GenericTxBuilder({
+      ...walletTxBuilderDependencies,
+      inputSelector: {
+        select: async ({ utxo, outputs }) => ({
+          remainingUTxO: new Set([...utxo].slice(1)),
+          selection: {
+            change: [] as Cardano.TxOut[],
+            fee: 2_000_000n,
+            inputs: new Set([[...utxo][0]]),
+            outputs
+          }
+        })
+      }
+    });
+    const tx = await txBuilder
+      .addOutput({ address: ownAddress, value: { coins: 2_000_000n } })
+      .build()
+      .sign();
+
+    await expect(txSubmitProvider.submitTx({ signedTransaction: tx.cbor })).rejects.toThrow(
+      expect.objectContaining({
+        innerError: expect.objectContaining({
+          code: TxSubmissionErrorCode.ValueNotConserved,
+          data: expect.objectContaining({
+            consumed: expect.objectContaining({ coins: expect.any(BigInt) }),
+            produced: expect.objectContaining({ coins: expect.any(BigInt) })
+          })
+        }),
+        reason: ProviderFailure.BadRequest
+      })
+    );
+  });
+
+  // this mapping is not implemented yet due to
+  // https://input-output-rnd.slack.com/archives/C06J663L2A2/p1735920667624239
+  it.skip('maps ProviderError{TxSubmissionError{IncompleteWithdrawals}}', async () => {
+    const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
+    if (rewardAccounts.some((acc) => !acc.dRepDelegatee || !acc.rewardBalance)) {
+      return logger.warn(
+        'Skipping IncompleteWithdrawals error test because there are either no rewards, or not delegated to drep'
+      );
+    }
+    const txBuilder = new GenericTxBuilder({
+      ...walletTxBuilderDependencies,
+      txBuilderProviders: {
+        ...walletTxBuilderDependencies.txBuilderProviders,
+        rewardAccounts: async () => {
+          const accounts = await walletTxBuilderDependencies.txBuilderProviders.rewardAccounts();
+          return accounts.map((account) => ({
+            ...account,
+            rewardBalance: account.rewardBalance - 1n
+          }));
+        }
+      }
+    });
+    const tx = await txBuilder
+      .addOutput({ address: ownAddress, value: { coins: 2_000_000n } })
+      .build()
+      .sign();
+
+    await expect(txSubmitProvider.submitTx({ signedTransaction: tx.cbor })).rejects.toThrow(
+      expect.objectContaining({
+        innerError: expect.objectContaining({
+          code: TxSubmissionErrorCode.IncompleteWithdrawals
+        }),
+        reason: ProviderFailure.BadRequest
+      })
+    );
+  });
+});