@cardano-sdk/e2e 0.49.4 → 0.49.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardano-sdk/e2e",
-  "version": "0.49.4",
+  "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,21 +75,22 @@
   "dependencies": {
     "@cardano-foundation/ledgerjs-hw-app-cardano": "^7.1.4",
     "@cardano-ogmios/client": "6.9.0",
-    "@cardano-sdk/cardano-services": "~0.33.4",
-    "@cardano-sdk/cardano-services-client": "~0.23.4",
-    "@cardano-sdk/core": "~0.42.2",
+    "@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.12.18",
-    "@cardano-sdk/hardware-trezor": "~0.6.17",
-    "@cardano-sdk/input-selection": "~0.13.32",
-    "@cardano-sdk/key-management": "~0.24.14",
-    "@cardano-sdk/ogmios": "~0.18.18",
-    "@cardano-sdk/tx-construction": "~0.24.1",
+    "@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.3",
-    "@cardano-sdk/util-rxjs": "~0.9.0",
-    "@cardano-sdk/wallet": "~0.47.1",
+    "@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",
     "axios": "^1.7.4",
     "bunyan": "^1.8.15",
@@ -118,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.12.48",
-    "@cardano-sdk/projection": "~0.12.18",
-    "@cardano-sdk/projection-typeorm": "~0.9.18",
-    "@cardano-sdk/web-extension": "~0.37.1",
+    "@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",
@@ -181,5 +182,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "90c0b02e4db5261975932bf9d149e79cc47b8d85"
+  "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
+      })
+    );
+  });
+});

package/test/wallet_epoch_0/PersonalWallet/cip30WalletApi.test.ts

@@ -0,0 +1,119 @@
+import * as Crypto from '@cardano-sdk/crypto';
+import { BaseWallet, cip30 } from '@cardano-sdk/wallet';
+import { Bip32Account, KeyRole, cip8 } from '@cardano-sdk/key-management';
+import { COSEKey, COSESign1 } from '@emurgo/cardano-message-signing-nodejs';
+import { Cardano, util } from '@cardano-sdk/core';
+import { Cip30DataSignature, SenderContext } from '@cardano-sdk/dapp-connector';
+import { HexBlob } from '@cardano-sdk/util';
+import { NEVER, firstValueFrom, of } from 'rxjs';
+import { buildDRepAddressFromDRepKey } from '../../../../wallet/test/util';
+import { getEnv, getWallet, walletReady, walletVariables } from '../../../src';
+import { logger } from '@cardano-sdk/util-dev';
+
+const env = getEnv(walletVariables);
+
+const decodeSignature = (dataSignature: Cip30DataSignature) => {
+  const coseKey = COSEKey.from_bytes(Buffer.from(dataSignature.key, 'hex'));
+  const coseSign1 = COSESign1.from_bytes(Buffer.from(dataSignature.signature, 'hex'));
+
+  const publicKeyHeader = coseKey.header(cip8.CoseLabel.x)!;
+  const publicKeyBytes = publicKeyHeader.as_bytes()!;
+  const publicKeyHex = util.bytesToHex(publicKeyBytes);
+  const signedData = coseSign1.signed_data();
+  return { coseKey, coseSign1, publicKeyHex, signedData };
+};
+
+describe('PersonalWallet/cip30WalletApi', () => {
+  let wallet: BaseWallet;
+  let drepKeyHashHex: Crypto.Ed25519KeyHashHex;
+  let drepPubKey: Crypto.Ed25519PublicKeyHex;
+  let walletApi: ReturnType<typeof cip30.createWalletApi>;
+  let bip32Account: Bip32Account;
+
+  beforeEach(async () => {
+    ({ wallet, bip32Account } = await getWallet({ env, logger, name: 'wallet' }));
+    await walletReady(wallet, 10n);
+
+    drepPubKey = (await wallet.governance.getPubDRepKey())!;
+    drepKeyHashHex = (await Crypto.Ed25519PublicKey.fromHex(drepPubKey!).hash()).hex();
+
+    walletApi = cip30.createWalletApi(
+      of(wallet),
+      {
+        signData: () => Promise.resolve({ cancel$: NEVER })
+      } as unknown as cip30.CallbackConfirmation,
+      { logger: console }
+    );
+  });
+
+  it('can signData with hex DRepID', async () => {
+    const signature = await walletApi.signData(
+      { sender: '' } as unknown as SenderContext,
+      drepKeyHashHex,
+      HexBlob('abc123')
+    );
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(drepPubKey);
+  });
+
+  it('can signData with bech32 type 6 addr DRepID', async () => {
+    const drepAddr = (await buildDRepAddressFromDRepKey(drepPubKey))?.toAddress()?.toBech32();
+    const signature = await walletApi.signData(
+      { sender: '' } as unknown as SenderContext,
+      drepAddr!,
+      HexBlob('abc123')
+    );
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(drepPubKey);
+  });
+
+  it('can signData with bech32 base address', async () => {
+    const [{ address, index }] = await firstValueFrom(wallet.addresses$);
+    const paymentKeyHex = (await bip32Account.derivePublicKey({ index, role: KeyRole.External })).hex();
+
+    const signature = await walletApi.signData({ sender: '' } as unknown as SenderContext, address, HexBlob('abc123'));
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(paymentKeyHex);
+  });
+
+  it('can signData with hex-encoded base address', async () => {
+    const [{ address, index }] = await firstValueFrom(wallet.addresses$);
+    const addressHex = Cardano.Address.fromBech32(address).toBytes();
+    const paymentKeyHex = (await bip32Account.derivePublicKey({ index, role: KeyRole.External })).hex();
+
+    const signature = await walletApi.signData(
+      { sender: '' } as unknown as SenderContext,
+      addressHex,
+      HexBlob('abc123')
+    );
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(paymentKeyHex);
+  });
+
+  it('can signData with bech32 base address', async () => {
+    const [{ rewardAccount, index }] = await firstValueFrom(wallet.addresses$);
+    const stakeKeyHex = (await bip32Account.derivePublicKey({ index, role: KeyRole.Stake })).hex();
+
+    const signature = await walletApi.signData(
+      { sender: '' } as unknown as SenderContext,
+      rewardAccount,
+      HexBlob('abc123')
+    );
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(stakeKeyHex);
+  });
+
+  it('can signData with hex-encoded reward account', async () => {
+    const [{ rewardAccount, index }] = await firstValueFrom(wallet.addresses$);
+    const rewardAccountHex = Cardano.Address.fromBech32(rewardAccount).toBytes();
+    const stakeKeyHex = (await bip32Account.derivePublicKey({ index, role: KeyRole.Stake })).hex();
+
+    const signature = await walletApi.signData(
+      { sender: '' } as unknown as SenderContext,
+      rewardAccountHex,
+      HexBlob('abc123')
+    );
+
+    expect(decodeSignature(signature).publicKeyHex).toEqual(stakeKeyHex);
+  });
+});

package/test/web-extension/extension/const.ts

@@ -17,12 +17,10 @@ export const selectors = {
   btnDelegate: '#multiDelegation .delegate button',
   btnGrantAccess: '#requestAccessGrant',
   btnSignAndBuildTx: '#buildAndSignTx',
-  btnSignDataWithDRepId: '#signDataWithDRepId',
   deactivateWallet: '#deactivateWallet',
   destroyWallet: '#destroyWallet',
   divAdaPrice: '#adaPrice',
   divBgPortDisconnectStatus: '#remoteApiPortDisconnect .bgPortDisconnect',
-  divDataSignature: '#dataSignature',
   divSignature: '#signature',
   divUiPortDisconnectStatus: '#remoteApiPortDisconnect .uiPortDisconnect',
   liPercents: '#multiDelegation .distribution li .percent',

package/test/web-extension/extension/ui.html

@@ -45,8 +45,6 @@
   <button id="buildAndSignTx">Build & Sign TX</button>
   <div>Signature: <span id="signature">-</span></div>
 
-  <button id="signDataWithDRepId">Sign Data with DRepID</button>
-  <div>Signature: <span id="dataSignature">-</span></div>
   <script src="ui.js"></script>
 </body>
 

package/test/web-extension/extension/ui.ts

@@ -124,23 +124,6 @@ const sendDelegationTx = async (portfolio: { pool: Cardano.StakePool; weight: nu
   document.querySelector('#multiDelegation .delegateTxId')!.textContent = msg;
 };
 
-const signDataWithDRepID = async (): Promise<void> => {
-  let msg: string;
-  const dRepId = 'drep1vpzcgfrlgdh4fft0p0ju70czkxxkuknw0jjztl3x7aqgm9q3hqyaz';
-  try {
-    const signature = await wallet.signData({
-      payload: HexBlob('abc123'),
-      signWith: Cardano.DRepID(dRepId)
-    });
-    msg = JSON.stringify(signature);
-  } catch (error) {
-    msg = `ERROR signing data with DRepID: ${JSON.stringify(error)}`;
-  }
-
-  // Set text with signature or error
-  document.querySelector(selectors.divDataSignature)!.textContent = msg;
-};
-
 const setAddresses = ({ address, stakeAddress }: { address: string; stakeAddress: string }): void => {
   document.querySelector(selectors.spanAddress)!.textContent = address;
   document.querySelector(selectors.spanStakeAddress)!.textContent = stakeAddress;
@@ -378,10 +361,6 @@ document.querySelector(selectors.btnSignAndBuildTx)!.addEventListener('click', a
   setSignature(signedTx.witness.signatures.values().next().value);
 });
 
-document
-  .querySelector(selectors.btnSignDataWithDRepId)!
-  .addEventListener('click', async () => await signDataWithDRepID());
-
 // Code below tests that a disconnected port in background script will result in the consumed API method call promise to reject
 // UI consumes API -> BG exposes fake API that closes port
 const disconnectPortTestObj = consumeRemoteApi(

package/test/web-extension/specs/wallet.spec.ts

@@ -23,9 +23,7 @@ describe('wallet', () => {
     liPools,
     liPercents,
     divBgPortDisconnectStatus,
-    divUiPortDisconnectStatus,
-    btnSignDataWithDRepId,
-    divDataSignature
+    divUiPortDisconnectStatus
   } = selectors;
 
   // The address is filled in by the tests, which are order dependent
@@ -137,11 +135,6 @@ describe('wallet', () => {
         await buildAndSign();
       });
 
-      it('can sign data with a DRepID', async () => {
-        await (await $(btnSignDataWithDRepId)).click();
-        await expect($(divDataSignature)).toHaveTextContaining('signature');
-      });
-
       it('can destroy second wallet before switching back to the first wallet', async () => {
         // Destroy also clears associated store. Store will be rebuilt during future activation of same wallet
         await $(destroyWallet).click();