fix: rm imports from @cardano-sdk/*/src/*

Author: mkazlauskas

Diff for: .eslintrc.js

@@ -23,6 +23,9 @@ module.exports = {
       2,
       "unix"
     ],
+    "no-restricted-imports": ["error", {
+      "patterns": ["@cardano-sdk/*/src/*"]
+    }],
     "new-cap": 0,
     "no-unused-expressions": 0,
     "no-useless-constructor": 0,

Diff for: packages/cip2/test/RoundRobinRandomImprove.test.ts

@@ -7,7 +7,6 @@ import {
   testInputSelectionFailureMode,
   testInputSelectionProperties
 } from './util';
-import { createOutput } from '@cardano-sdk/util-dev/src/cslTestUtil';
 import { roundRobinRandomImprove } from '../src/RoundRobinRandomImprove';
 import fc from 'fast-check';
 
@@ -37,7 +36,7 @@ describe('RoundRobinRandomImprove', () => {
       });
       it('Selects UTxO even when implicit input covers outputs', async () => {
         const utxo = new Set([CslTestUtil.createUnspentTxOutput({ coins: 10_000_000n })]);
-        const outputs = new Set([createOutput({ coins: 1_000_000n })]);
+        const outputs = new Set([CslTestUtil.createOutput({ coins: 1_000_000n })]);
         const results = await roundRobinRandomImprove().select({
           constraints: SelectionConstraints.NO_CONSTRAINTS,
           implicitCoin: { input: 2_000_000n },

Diff for: packages/core/test/CSL/coreToCsl.test.ts

@@ -1,6 +1,5 @@
 /* eslint-disable max-len */
 import { Asset, CSL, Cardano, coreToCsl } from '../../src';
-import { CertificateType } from '@cardano-sdk/core/src/Cardano';
 
 const txIn: Cardano.TxIn = {
   address:
@@ -23,7 +22,7 @@ const txOut: Cardano.TxOut = {
 const coreTxBody: Cardano.TxBodyAlonzo = {
   certificates: [
     {
-      __typename: CertificateType.PoolRetirement,
+      __typename: Cardano.CertificateType.PoolRetirement,
       epoch: 500,
       poolId: 'pool1y6chk7x7fup4ms9leesdr57r4qy9cwxuee0msan72x976a6u0nc'
     }

Diff for: packages/util-dev/src/createStubStakePoolSearchProvider.ts

@@ -1,8 +1,7 @@
-import { StakePool } from '@cardano-sdk/core/src/Cardano';
-import { StakePoolSearchProvider } from '@cardano-sdk/core';
+import { Cardano, StakePoolSearchProvider } from '@cardano-sdk/core';
 import delay from 'delay';
 
-export const somePartialStakePools: StakePool[] = [
+export const somePartialStakePools: Cardano.StakePool[] = [
   {
     hexId: 'cf12a9dcaacdc09778616d60502011a88ed4542c482f2ddd08d8ac5a',
     id: 'pool1euf2nh92ehqfw7rpd4s9qgq34z8dg4pvfqhjmhggmzk95gcd402',
@@ -23,13 +22,13 @@ export const somePartialStakePools: StakePool[] = [
       ticker: 'VEGA2'
     }
   }
-] as StakePool[];
+] as Cardano.StakePool[];
 
 /**
  * Good source for testnet pools: https://testnet.adatools.io/pools
  */
 export const createStubStakePoolSearchProvider = (
-  stakePools: StakePool[] = somePartialStakePools,
+  stakePools: Cardano.StakePool[] = somePartialStakePools,
   delayMs?: number
 ): StakePoolSearchProvider => ({
   queryStakePools: async (fragments) => {

Diff for: packages/wallet/src/Transaction/computeImplicitCoin.ts

@@ -1,5 +1,4 @@
 import { BigIntMath, Cardano, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { CertificateType } from '@cardano-sdk/core/src/Cardano';
 import { InitializeTxProps } from '../types';
 
 /**
@@ -14,17 +13,17 @@ export const computeImplicitCoin = (
   const deposit = BigIntMath.sum(
     certificates?.map(
       (cert) =>
-        (cert.__typename === CertificateType.StakeRegistration && stakeKeyDepositBigint) ||
-        (cert.__typename === CertificateType.PoolRegistration && poolDepositBigint) ||
+        (cert.__typename === Cardano.CertificateType.StakeRegistration && stakeKeyDepositBigint) ||
+        (cert.__typename === Cardano.CertificateType.PoolRegistration && poolDepositBigint) ||
         0n
     ) || []
   );
   const withdrawalsTotal = (withdrawals && BigIntMath.sum(withdrawals.map(({ quantity }) => quantity))) || 0n;
   const reclaimTotal = BigIntMath.sum(
     certificates?.map(
       (cert) =>
-        (cert.__typename === CertificateType.StakeDeregistration && stakeKeyDepositBigint) ||
-        (cert.__typename === CertificateType.PoolRetirement && poolDepositBigint) ||
+        (cert.__typename === Cardano.CertificateType.StakeDeregistration && stakeKeyDepositBigint) ||
+        (cert.__typename === Cardano.CertificateType.PoolRetirement && poolDepositBigint) ||
         0n
     ) || []
   );

Diff for: packages/wallet/src/services/DelegationTracker/DelegationTracker.ts

@@ -1,6 +1,5 @@
 /* eslint-disable unicorn/no-nested-ternary */
 import { Cardano, StakePoolSearchProvider, WalletProvider } from '@cardano-sdk/core';
-import { CertificateType, Epoch, NewTxAlonzo } from '@cardano-sdk/core/src/Cardano';
 import { Delegation, Transactions } from '../types';
 import { DelegationKeyStatus } from '..';
 import { KeyManager } from '../../KeyManagement';
@@ -30,7 +29,7 @@ export interface DelegationTrackerProps {
   walletProvider: WalletProvider;
   keyManager: KeyManager;
   stakePoolSearchProvider: StakePoolSearchProvider;
-  epoch$: Observable<Epoch>;
+  epoch$: Observable<Cardano.Epoch>;
   transactionsTracker: Transactions;
   retryBackoffConfig: RetryBackoffConfig;
   internals?: {
@@ -56,7 +55,7 @@ export const certificateTransactionsWithEpochs = (
 
 export const createRewardAccountsTracker = (
   transactions$: Observable<TxWithEpoch[]>,
-  transactionsInFlight$: Observable<NewTxAlonzo[]>
+  transactionsInFlight$: Observable<Cardano.NewTxAlonzo[]>
 ) =>
   combineLatest([transactions$, transactionsInFlight$]).pipe(
     map(([transactions, transactionsInFlight]) => [transactions.map(({ tx }) => tx), transactionsInFlight]),
@@ -107,9 +106,9 @@ export const createDelegationTracker = ({
   } = {}
 }: DelegationTrackerProps): Delegation => {
   const transactions$ = certificateTransactionsWithEpochs(transactionsTracker, blockEpochProvider, [
-    CertificateType.StakeDelegation,
-    CertificateType.StakeRegistration,
-    CertificateType.StakeDeregistration
+    Cardano.CertificateType.StakeDelegation,
+    Cardano.CertificateType.StakeRegistration,
+    Cardano.CertificateType.StakeDeregistration
   ]);
   const rewardsHistory$ = new TrackerSubject(createRewardsHistoryTracker(transactions$, rewardsHistoryProvider));
   const delegatee$ = new TrackerSubject(createDelegateeTracker(queryStakePoolsProvider, epoch$, transactions$));

Diff for: packages/wallet/src/services/DelegationTracker/RewardsHistory.ts

@@ -1,11 +1,10 @@
-import { BigIntMath, Cardano, WalletProvider } from '@cardano-sdk/core';
+import { BigIntMath, Cardano, WalletProvider, util } from '@cardano-sdk/core';
 import { KeyManager } from '../../KeyManagement';
 import { Observable, distinctUntilChanged, map, of, switchMap } from 'rxjs';
 import { RetryBackoffConfig } from 'backoff-rxjs';
 import { TxWithEpoch } from './types';
 import { coldObservableProvider, transactionHasAnyCertificate } from '../util';
 import { first } from 'lodash-es';
-import { isNotNil } from '@cardano-sdk/core/src/util/misc';
 
 export const createRewardsHistoryProvider =
   (walletProvider: WalletProvider, keyManager: KeyManager, retryBackoffConfig: RetryBackoffConfig) =>
@@ -26,7 +25,7 @@ const firstDelegationEpoch$ = (transactions$: Observable<TxWithEpoch[]>) =>
         transactions.filter(({ tx }) => transactionHasAnyCertificate(tx, [Cardano.CertificateType.StakeDelegation]))
       )
     ),
-    map((tx) => (isNotNil(tx) ? tx.epoch + 2 : null)),
+    map((tx) => (util.isNotNil(tx) ? tx.epoch + 2 : null)),
     distinctUntilChanged()
   );
 

Diff for: packages/wallet/src/services/DelegationTracker/transactionCertificates.ts

@@ -1,6 +1,5 @@
 import { Cardano, util } from '@cardano-sdk/core';
 import { Transactions } from '../types';
-import { TxBodyAlonzo } from '@cardano-sdk/core/src/Cardano';
 import { distinctUntilChanged, map } from 'rxjs';
 import { last } from 'lodash-es';
 import { transactionsEquals } from '../util/equals';
@@ -10,7 +9,7 @@ export const RegAndDeregCertificateTypes = [
   Cardano.CertificateType.StakeDeregistration
 ];
 
-export const transactionStakeKeyCertficates = (body: TxBodyAlonzo) =>
+export const transactionStakeKeyCertficates = (body: Cardano.TxBodyAlonzo) =>
   (body.certificates || []).filter((certificate): certificate is Cardano.StakeAddressCertificate =>
     RegAndDeregCertificateTypes.includes(certificate.__typename)
   );
@@ -21,7 +20,7 @@ export const transactionHasAnyCertificate = (
 ) => certificates?.some(({ __typename }) => certificateTypes.includes(__typename)) || false;
 
 export const isLastStakeKeyCertOfType = (
-  transactions: { body: TxBodyAlonzo }[],
+  transactions: { body: Cardano.TxBodyAlonzo }[],
   certType: Cardano.CertificateType.StakeRegistration | Cardano.CertificateType.StakeDeregistration,
   rewardAccount?: Cardano.Address
 ) => {

Diff for: packages/wallet/src/services/util/equals.ts

@@ -1,12 +1,11 @@
 import { Cardano } from '@cardano-sdk/core';
-import { TxAlonzo } from '@cardano-sdk/core/src/Cardano';
 
 export const strictEquals = <T>(a: T, b: T) => a === b;
 
 export const arrayEquals = <T>(arrayA: T[], arrayB: T[], itemEquals: (a: T, b: T) => boolean) =>
   arrayA.length === arrayB.length && arrayA.every((a) => arrayB.some((b) => itemEquals(a, b)));
 
-export const txEquals = (a: TxAlonzo, b: TxAlonzo) => a.id === b.id;
+export const txEquals = (a: Cardano.TxAlonzo, b: Cardano.TxAlonzo) => a.id === b.id;
 
 export const transactionsEquals = (a: Cardano.TxAlonzo[], b: Cardano.TxAlonzo[]) => arrayEquals(a, b, txEquals);
 

Diff for: packages/wallet/test/SingleAddressWallet.test.ts

@@ -2,7 +2,6 @@
 import * as mocks from './mocks';
 import { Cardano } from '@cardano-sdk/core';
 import { KeyManagement, SingleAddressWallet } from '../src';
-import { coalesceValueQuantities } from '@cardano-sdk/core/src/Cardano/util';
 import { createStubStakePoolSearchProvider } from '@cardano-sdk/util-dev';
 import { firstValueFrom, skip } from 'rxjs';
 
@@ -41,7 +40,7 @@ describe('SingleAddressWallet', () => {
       await firstValueFrom(wallet.balance.available$);
       await firstValueFrom(wallet.balance.total$);
       expect(wallet.balance.available$.value?.coins).toEqual(
-        coalesceValueQuantities(mocks.utxo.map((utxo) => utxo[1].value)).coins
+        Cardano.util.coalesceValueQuantities(mocks.utxo.map((utxo) => utxo[1].value)).coins
       );
       expect(wallet.balance.total$.value?.rewards).toBe(mocks.rewards);
     });

Diff for: packages/wallet/test/Transaction/computeImplicitCoin.test.ts

@@ -1,17 +1,16 @@
 import { Cardano, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { CertificateType } from '@cardano-sdk/core/src/Cardano';
 import { InitializeTxProps, Transaction } from '../../src';
 
 describe('Transaction.computeImplicitCoin', () => {
   it('sums registrations for deposit, withdrawals and deregistrations for input', async () => {
     const protocolParameters = { poolDeposit: 3, stakeKeyDeposit: 2 } as ProtocolParametersRequiredByWallet;
     const address = 'stake...';
     const certificates: Cardano.Certificate[] = [
-      { __typename: CertificateType.StakeRegistration, address },
-      { __typename: CertificateType.StakeDeregistration, address },
-      { __typename: CertificateType.StakeRegistration, address },
-      { __typename: CertificateType.PoolRetirement, epoch: 500, poolId: 'pool...' },
-      { __typename: CertificateType.StakeDelegation, address, epoch: 500, poolId: 'pool...' }
+      { __typename: Cardano.CertificateType.StakeRegistration, address },
+      { __typename: Cardano.CertificateType.StakeDeregistration, address },
+      { __typename: Cardano.CertificateType.StakeRegistration, address },
+      { __typename: Cardano.CertificateType.PoolRetirement, epoch: 500, poolId: 'pool...' },
+      { __typename: Cardano.CertificateType.StakeDelegation, address, epoch: 500, poolId: 'pool...' }
     ];
     const withdrawals: Cardano.Withdrawal[] = [{ quantity: 5n, stakeAddress: address }];
     const txProps = { certificates, withdrawals } as InitializeTxProps;

Diff for: packages/wallet/test/integration/withdrawal.test.ts

@@ -1,5 +1,4 @@
 import { Cardano } from '@cardano-sdk/core';
-import { CertificateType } from '@cardano-sdk/core/src/Cardano';
 import { KeyManagement, SingleAddressWallet, SingleAddressWalletProps, TransactionFailure } from '../../src';
 import { createStubStakePoolSearchProvider } from '@cardano-sdk/util-dev';
 import { firstValueFrom } from 'rxjs';
@@ -36,7 +35,7 @@ describe('integration/withdrawal', () => {
     const availableRewards = wallet.balance.available$.value!.rewards;
 
     const txInternals = await wallet.initializeTx({
-      certificates: [{ __typename: CertificateType.StakeDeregistration, address: keyManager.rewardAccount }],
+      certificates: [{ __typename: Cardano.CertificateType.StakeDeregistration, address: keyManager.rewardAccount }],
       outputs: new Set(), // In a real transaction you would probably want to have some outputs
       withdrawals: [{ quantity: availableRewards, stakeAddress: keyManager.rewardAccount }]
     });

Diff for: packages/wallet/test/mocks/mockWalletProvider.ts

@@ -1,7 +1,7 @@
 // TODO: rename to MockWalletProvider since it's using jest.fn() mocks
 /* eslint-disable max-len */
+import { AssetId } from '@cardano-sdk/util-dev';
 import { Cardano, EpochRewards, WalletProvider } from '@cardano-sdk/core';
-import { PXL, TSLA } from '@cardano-sdk/util-dev/src/assetId';
 
 export const stakeKeyHash = 'stake_test1up7pvfq8zn4quy45r2g572290p9vf99mr9tn7r9xrgy2l2qdsf58d';
 
@@ -18,8 +18,8 @@ export const utxo: Cardano.Utxo[] = [
         'addr_test1qzs0umu0s2ammmpw0hea0w2crtcymdjvvlqngpgqy76gpfnuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475qp3y3vz',
       value: {
         assets: {
-          [PXL]: 5n,
-          [TSLA]: 10n
+          [AssetId.PXL]: 5n,
+          [AssetId.TSLA]: 10n
         },
         coins: 4_027_026_465n
       }
@@ -37,7 +37,7 @@ export const utxo: Cardano.Utxo[] = [
         'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g',
       value: {
         assets: {
-          [TSLA]: 15n
+          [AssetId.TSLA]: 15n
         },
         coins: 3_289_566n
       }

Diff for: packages/wallet/test/services/BalanceTracker.test.ts

@@ -4,7 +4,6 @@
 /* eslint-disable space-in-parens */
 import { BehaviorObservable, Delegation, DelegationKeyStatus, RewardAccount, createBalanceTracker } from '../../src/services';
 import { Cardano, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { coalesceValueQuantities } from '@cardano-sdk/core/src/Cardano/util';
 import { createTestScheduler } from '../testScheduler';
 import { utxo } from '../mocks';
 
@@ -27,16 +26,16 @@ describe('createBalanceTracker', () => {
         { rewardAccounts$ } as Delegation
       );
       expectObservable(balanceTracker.total$).toBe('-a--bc-', {
-        a: { ...coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 10n },
-        b: { ...coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 20n },
-        c: { ...coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 2n, rewards: 20n }
+        a: { ...Cardano.util.coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 10n },
+        b: { ...Cardano.util.coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 20n },
+        c: { ...Cardano.util.coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 2n, rewards: 20n }
       });
       expectObservable(balanceTracker.available$).toBe('--abcde', {
-        a: { ...coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 10n },
-        b: { ...coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 5n },
-        c: { ...coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 0n, rewards: 5n },
-        d: { ...coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 2n, rewards: 5n },
-        e: { ...coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 0n, rewards: 5n }
+        a: { ...Cardano.util.coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 10n },
+        b: { ...Cardano.util.coalesceValueQuantities(utxo.map((u) => u[1].value)), deposit: 0n, rewards: 5n },
+        c: { ...Cardano.util.coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 0n, rewards: 5n },
+        d: { ...Cardano.util.coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 2n, rewards: 5n },
+        e: { ...Cardano.util.coalesceValueQuantities(utxo.slice(1).map((u) => u[1].value)), deposit: 0n, rewards: 5n }
       });
     });
   });

Diff for: packages/wallet/test/services/DelegationTracker/DelegationTracker.test.ts

@@ -1,6 +1,5 @@
 import { Cardano, WalletProvider } from '@cardano-sdk/core';
 import { DelegationKeyStatus, Transactions } from '../../../src/services';
-import { NewTxAlonzo } from '@cardano-sdk/core/src/Cardano';
 import { RetryBackoffConfig } from 'backoff-rxjs';
 import { TxWithEpoch } from '../../../src/services/DelegationTracker/types';
 import {
@@ -41,12 +40,12 @@ describe('DelegationTracker', () => {
         b: [
           {
             body: { certificates: [{ __typename: Cardano.CertificateType.StakeRegistration, address }] }
-          } as NewTxAlonzo
+          } as Cardano.NewTxAlonzo
         ],
         c: [
           {
             body: { certificates: [{ __typename: Cardano.CertificateType.StakeDeregistration, address }] }
-          } as NewTxAlonzo
+          } as Cardano.NewTxAlonzo
         ]
       });
       const tracker$ = createRewardAccountsTracker(transactions$, transactionsInFlight$);

Diff for: packages/wallet/test/services/util/equals.test.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Cardano } from '@cardano-sdk/core';
-import { TxAlonzo } from '@cardano-sdk/core/src/Cardano';
 import { arrayEquals, strictEquals, transactionsEquals, txEquals, utxoEquals } from '../../../src';
 
 describe('equals', () => {
@@ -22,8 +21,8 @@ describe('equals', () => {
 
   test('transactionsEquals', () => {
     expect(transactionsEquals([], [])).toBe(true);
-    expect(transactionsEquals([{ id: 'id1' } as TxAlonzo], [{ id: 'id2' } as TxAlonzo])).toBe(false);
-    expect(transactionsEquals([{ id: 'id1' } as TxAlonzo], [{ id: 'id1' } as TxAlonzo])).toBe(true);
+    expect(transactionsEquals([{ id: 'id1' } as Cardano.TxAlonzo], [{ id: 'id2' } as Cardano.TxAlonzo])).toBe(false);
+    expect(transactionsEquals([{ id: 'id1' } as Cardano.TxAlonzo], [{ id: 'id1' } as Cardano.TxAlonzo])).toBe(true);
   });
 
   test('utxoEquals ', () => {