@cardano-sdk/wallet 0.1.4 → 0.1.5

package/test/InMemoryTransactionTracker.test.ts

@@ -1,108 +0,0 @@
-import { CardanoSerializationLib, CSL, ProviderError, ProviderFailure } from '@cardano-sdk/core';
-import { dummyLogger } from 'ts-log';
-import { ledgerTip, providerStub, ProviderStub, queryTransactionsResult } from './mocks';
-import mockDelay from 'delay';
-import { TransactionTrackerEvent, InMemoryTransactionTracker, TransactionFailure } from '../src';
-
-jest.mock('delay', () => jest.fn().mockResolvedValue(void 0));
-
-describe('InMemoryTransactionTracker', () => {
-  const POLL_INTERVAL = 1000;
-  let ledgerTipSlot: number;
-  let provider: ProviderStub;
-  let txTracker: InMemoryTransactionTracker;
-  let hash_transaction: jest.Mock;
-
-  const mockHashTransactionReturn = (resultHash: string) => {
-    hash_transaction.mockReturnValue({
-      to_bytes() {
-        return Buffer.from(resultHash);
-      }
-    });
-  };
-
-  beforeEach(() => {
-    provider = providerStub();
-    provider.queryTransactionsByHashes.mockReturnValue([queryTransactionsResult[0]]);
-    hash_transaction = jest.fn();
-    mockHashTransactionReturn('some-hash');
-    txTracker = new InMemoryTransactionTracker({
-      provider,
-      csl: { hash_transaction } as unknown as CardanoSerializationLib,
-      logger: dummyLogger,
-      pollInterval: POLL_INTERVAL
-    });
-    ledgerTipSlot = ledgerTip.slot;
-    (mockDelay as unknown as jest.Mock).mockReset();
-  });
-
-  describe('track', () => {
-    let onTransaction: jest.Mock;
-
-    beforeEach(() => {
-      onTransaction = jest.fn();
-      txTracker.on(TransactionTrackerEvent.NewTransaction, onTransaction);
-    });
-
-    it('cannot track transactions that have no validity interval', async () => {
-      await expect(() =>
-        txTracker.track({
-          body: () => ({
-            ttl: () => void 0
-          })
-        } as unknown as CSL.Transaction)
-      ).rejects.toThrowError(TransactionFailure.CannotTrack);
-    });
-
-    describe('valid transaction', () => {
-      let transaction: CSL.Transaction;
-
-      beforeEach(async () => {
-        transaction = {
-          body: () => ({
-            ttl: () => ledgerTipSlot
-          })
-        } as unknown as CSL.Transaction;
-      });
-
-      it('throws CannotTrack on ledger tip fetch error', async () => {
-        provider.queryTransactionsByHashes.mockResolvedValueOnce([]);
-        provider.ledgerTip.mockRejectedValueOnce(new ProviderError(ProviderFailure.Unknown));
-        await expect(txTracker.track(transaction)).rejects.toThrowError(TransactionFailure.CannotTrack);
-        expect(provider.ledgerTip).toBeCalledTimes(1);
-        expect(provider.queryTransactionsByHashes).toBeCalledTimes(1);
-      });
-
-      it('polls provider at "pollInterval" until it returns the transaction', async () => {
-        // resolve [] or reject with 404 should be treated the same
-        provider.queryTransactionsByHashes.mockResolvedValueOnce([]);
-        provider.queryTransactionsByHashes.mockRejectedValueOnce(new ProviderError(ProviderFailure.NotFound));
-        await txTracker.track(transaction);
-        expect(provider.queryTransactionsByHashes).toBeCalledTimes(3);
-        expect(mockDelay).toBeCalledTimes(3);
-        expect(mockDelay).toBeCalledWith(POLL_INTERVAL);
-      });
-
-      it('throws after timeout', async () => {
-        provider.queryTransactionsByHashes.mockResolvedValueOnce([]);
-        provider.ledgerTip.mockResolvedValueOnce({ slot: ledgerTipSlot + 1 });
-        await expect(txTracker.track(transaction)).rejects.toThrowError(TransactionFailure.Timeout);
-      });
-
-      it('emits "transaction" event for tracked transactions, returns promise unique per pending tx', async () => {
-        const promise1 = txTracker.track(transaction);
-        const promise2 = txTracker.track(transaction);
-        await promise1;
-        await promise2;
-        mockHashTransactionReturn('other-hash');
-        await txTracker.track(transaction);
-        expect(provider.queryTransactionsByHashes).toBeCalledTimes(2);
-        expect(onTransaction).toBeCalledTimes(2);
-        // assert it clears cache
-        await txTracker.track(transaction);
-        expect(provider.queryTransactionsByHashes).toBeCalledTimes(3);
-        expect(onTransaction).toBeCalledTimes(3);
-      });
-    });
-  });
-});

package/test/InMemoryUtxoRepository.test.ts

@@ -1,242 +0,0 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-/* eslint-disable promise/param-names */
-import { roundRobinRandomImprove, InputSelector } from '@cardano-sdk/cip2';
-import { loadCardanoSerializationLib, CardanoSerializationLib, CSL, Ogmios, Cardano } from '@cardano-sdk/core';
-import { flushPromises, SelectionConstraints } from '@cardano-sdk/util-dev';
-import {
-  providerStub,
-  delegate,
-  rewards,
-  ProviderStub,
-  utxo,
-  delegationAndRewards,
-  MockTransactionTracker
-} from './mocks';
-import {
-  InMemoryUtxoRepository,
-  KeyManagement,
-  TransactionTrackerEvent,
-  UtxoRepository,
-  UtxoRepositoryEvent,
-  UtxoRepositoryFields
-} from '../src';
-import { ogmiosToCsl } from '@cardano-sdk/core/src/Ogmios';
-import { TxIn, TxOut } from '@cardano-ogmios/schema';
-import { TransactionError, TransactionFailure } from '../src/TransactionError';
-
-const addresses = [
-  'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g'
-];
-
-describe('InMemoryUtxoRepository', () => {
-  let utxoRepository: UtxoRepository;
-  let provider: ProviderStub;
-  let inputSelector: InputSelector;
-  let csl: CardanoSerializationLib;
-  let keyManager: KeyManagement.KeyManager;
-  let outputs: Set<CSL.TransactionOutput>;
-  let txTracker: MockTransactionTracker;
-
-  beforeEach(async () => {
-    provider = providerStub();
-    csl = await loadCardanoSerializationLib();
-    inputSelector = roundRobinRandomImprove(csl);
-    keyManager = KeyManagement.createInMemoryKeyManager({
-      csl,
-      mnemonicWords: KeyManagement.util.generateMnemonicWords(),
-      networkId: 0,
-      password: '123'
-    });
-    outputs = new Set([
-      Ogmios.ogmiosToCsl(csl).txOut({
-        address: addresses[0],
-        value: { coins: 4_000_000 }
-      }),
-      Ogmios.ogmiosToCsl(csl).txOut({
-        address: addresses[0],
-        value: { coins: 2_000_000 }
-      })
-    ]);
-    txTracker = new MockTransactionTracker();
-    utxoRepository = new InMemoryUtxoRepository({
-      csl,
-      provider,
-      keyManager,
-      inputSelector,
-      txTracker
-    });
-  });
-
-  test('constructed state', async () => {
-    expect(utxoRepository.allUtxos.length).toBe(0);
-    expect(utxoRepository.allRewards).toBe(null);
-    expect(utxoRepository.delegation).toBe(null);
-  });
-
-  test('sync', async () => {
-    const syncedHandler = jest.fn();
-    utxoRepository.on(UtxoRepositoryEvent.Changed, syncedHandler);
-    await utxoRepository.sync();
-    const expectedFields: UtxoRepositoryFields = {
-      allUtxos: utxo,
-      availableUtxos: utxo,
-      allRewards: rewards,
-      availableRewards: rewards,
-      delegation: delegate
-    };
-    expect(utxoRepository).toMatchObject(expectedFields);
-    expect(syncedHandler).toBeCalledTimes(1);
-    expect(syncedHandler).toBeCalledWith(expectedFields);
-    const identicalUtxo = [{ ...utxo[1][0] }, { ...utxo[1][1] }] as const; // clone UTxO
-    provider.utxoDelegationAndRewards.mockResolvedValueOnce({
-      utxo: [utxo[0], identicalUtxo],
-      delegationAndRewards
-    });
-    await utxoRepository.sync();
-    expect(utxoRepository.allUtxos.length).toBe(2);
-    // Verify we're not replacing the object with an identical one in the UTxO set
-    expect(utxoRepository.allUtxos).not.toContain(identicalUtxo);
-    expect(utxoRepository.allUtxos).toContain(utxo[1]);
-    expect(syncedHandler).toBeCalledTimes(2);
-  });
-
-  describe('selectInputs', () => {
-    it('can be called without explicitly syncing', async () => {
-      const result = await utxoRepository.selectInputs(outputs, SelectionConstraints.NO_CONSTRAINTS);
-      expect(utxoRepository.allUtxos.length).toBe(3);
-      expect(utxoRepository.allRewards).toBe(rewards);
-      expect(utxoRepository.delegation).toBe(delegate);
-      expect(result.selection.inputs.size).toBeGreaterThan(0);
-      expect(result.selection.outputs).toBe(outputs);
-      expect(result.selection.change.size).toBe(2);
-    });
-  });
-
-  describe('availableUtxos and availableRewards', () => {
-    let transactionUtxo: [TxIn, TxOut];
-    let transaction: CSL.Transaction;
-    let numUtxoPreTransaction: number;
-    let rewardsPreTransaction: bigint;
-    let onOutOfSync: jest.Mock;
-    let completeConfirmation: Function;
-    const transactionWithdrawal = 1n;
-
-    const trackTransaction = async (confirmed: Promise<void>) => {
-      const syncedHandler = jest.fn();
-      utxoRepository.on(UtxoRepositoryEvent.Changed, syncedHandler);
-      await txTracker.emit(TransactionTrackerEvent.NewTransaction, {
-        transaction,
-        confirmed
-      });
-      // transaction not yet confirmed
-      expect(utxoRepository.availableUtxos).toHaveLength(utxoRepository.allUtxos.length - 1);
-      expect(utxoRepository.availableUtxos).not.toContain(transactionUtxo);
-      expect(syncedHandler).toBeCalledTimes(1);
-      expect(syncedHandler).toBeCalledWith({
-        allUtxos: utxo,
-        availableUtxos: utxo.slice(1),
-        allRewards: rewards,
-        availableRewards: rewards - transactionWithdrawal,
-        delegation: delegate
-      } as UtxoRepositoryFields);
-    };
-
-    const assertThereAreNoPendingTransactionsOrRewards = () => {
-      expect(utxoRepository.availableUtxos).toHaveLength(utxoRepository.allUtxos.length);
-      expect(utxoRepository.allRewards).toBe(utxoRepository.availableRewards);
-    };
-
-    beforeEach(async () => {
-      transactionUtxo = utxo[0];
-      transaction = {
-        body: () => ({
-          inputs: () => ({
-            len: () => 1,
-            get: () => ogmiosToCsl(csl).txIn(transactionUtxo[0])
-          }),
-          withdrawals: () => ({
-            keys: () => ({
-              len: () => 1,
-              get: () =>
-                csl.RewardAddress.new(
-                  Cardano.NetworkId.testnet,
-                  csl.StakeCredential.from_keyhash(keyManager.stakeKey.hash())
-                )
-            }),
-            len: () => 1,
-            get: () => csl.BigNum.from_str(transactionWithdrawal.toString())
-          })
-        })
-      } as unknown as CSL.Transaction;
-      await utxoRepository.sync();
-      numUtxoPreTransaction = utxoRepository.allUtxos.length;
-      rewardsPreTransaction = utxoRepository.allRewards!;
-      onOutOfSync = jest.fn();
-      utxoRepository.on(UtxoRepositoryEvent.OutOfSync, onOutOfSync);
-    });
-
-    it('preconditions', () => {
-      expect(utxoRepository.availableUtxos).toHaveLength(utxoRepository.allUtxos.length);
-      expect(utxoRepository.availableUtxos).toContain(transactionUtxo);
-      expect(utxoRepository.availableRewards).toBe(rewardsPreTransaction);
-    });
-
-    describe('sync success', () => {
-      beforeEach(() => {
-        // Simulate spent utxo and rewards
-        expect(provider.utxoDelegationAndRewards).toBeCalledTimes(1);
-        provider.utxoDelegationAndRewards.mockResolvedValueOnce({
-          utxo: utxo.slice(1),
-          delegationAndRewards: {
-            ...delegationAndRewards,
-            rewards: rewards - transactionWithdrawal
-          }
-        });
-      });
-
-      const confirmTxAndAssertUtxoRepositorySynced = async () => {
-        await completeConfirmation!();
-        await flushPromises();
-        // Assert values from provider sync
-        expect(provider.utxoDelegationAndRewards).toBeCalledTimes(2);
-        expect(utxoRepository.availableUtxos).toHaveLength(numUtxoPreTransaction - 1);
-        expect(utxoRepository.availableUtxos).not.toContain(transactionUtxo);
-        expect(utxoRepository.availableRewards).toBe(rewardsPreTransaction - transactionWithdrawal);
-        expect(onOutOfSync).not.toBeCalled();
-      };
-
-      it('transaction confirmed', async () => {
-        await trackTransaction(new Promise<void>((resolve) => (completeConfirmation = resolve)));
-        await confirmTxAndAssertUtxoRepositorySynced();
-        assertThereAreNoPendingTransactionsOrRewards();
-      });
-
-      it('transaction confirmation failed', async () => {
-        // setup for transaction to timeout
-        await trackTransaction(
-          new Promise<void>(
-            (_, reject) => (completeConfirmation = () => reject(new TransactionError(TransactionFailure.Timeout)))
-          )
-        );
-        await confirmTxAndAssertUtxoRepositorySynced();
-        assertThereAreNoPendingTransactionsOrRewards();
-      });
-    });
-
-    it('emits OutOfSync on sync failure', async () => {
-      provider.utxoDelegationAndRewards.mockRejectedValueOnce(new Error('any error'));
-
-      const confirmed = new Promise<void>((resolve) => (completeConfirmation = resolve));
-      await trackTransaction(confirmed);
-
-      // transaction confirmed
-      await completeConfirmation!();
-      await flushPromises();
-      expect(utxoRepository.availableUtxos).toHaveLength(numUtxoPreTransaction);
-      expect(utxoRepository.availableUtxos).toContain(transactionUtxo);
-      expect(utxoRepository.allRewards).toBe(rewardsPreTransaction);
-      expect(onOutOfSync).toBeCalledTimes(1);
-      assertThereAreNoPendingTransactionsOrRewards();
-    });
-  });
-});

package/test/KeyManagement/InMemoryKeyManager.test.ts

@@ -1,39 +0,0 @@
-import { Cardano, CardanoSerializationLib, loadCardanoSerializationLib } from '@cardano-sdk/core';
-import { Buffer } from 'buffer';
-import { KeyManagement } from '../../src';
-
-describe('InMemoryKeyManager', () => {
-  let keyManager: KeyManagement.KeyManager;
-  let csl: CardanoSerializationLib;
-
-  beforeEach(async () => {
-    csl = await loadCardanoSerializationLib();
-    const mnemonicWords = KeyManagement.util.generateMnemonicWords();
-    keyManager = KeyManagement.createInMemoryKeyManager({
-      csl,
-      mnemonicWords,
-      networkId: Cardano.NetworkId.testnet,
-      password: '123'
-    });
-    expect(keyManager.publicKey).toBeInstanceOf(csl.PublicKey);
-  });
-
-  test('initial state publicKey', async () => {
-    expect(keyManager.publicKey).toBeDefined();
-    expect(keyManager.publicParentKey).toBeDefined();
-  });
-
-  test('deriveAddress', async () => {
-    const address = await keyManager.deriveAddress(0, 0);
-    expect(address).toBeDefined();
-    expect(keyManager.publicParentKey).toBeDefined();
-  });
-
-  test('signTransaction', async () => {
-    const txHash = csl.TransactionHash.from_bytes(
-      Buffer.from('8561258e210352fba2ac0488afed67b3427a27ccf1d41ec030c98a8199bc22ec', 'hex')
-    );
-    const witnessSet = await keyManager.signTransaction(txHash);
-    expect(witnessSet).toBeInstanceOf(csl.TransactionWitnessSet);
-  });
-});

package/test/SingleAddressWallet.test.ts

@@ -1,87 +0,0 @@
-/* eslint-disable max-len */
-import { loadCardanoSerializationLib, CardanoSerializationLib, Cardano } from '@cardano-sdk/core';
-import { InputSelector, roundRobinRandomImprove } from '@cardano-sdk/cip2';
-import { ProviderStub, providerStub, txTracker } from './mocks';
-import {
-  BalanceTracker,
-  createSingleAddressWallet,
-  InMemoryUtxoRepository,
-  KeyManagement,
-  SingleAddressWallet,
-  SingleAddressWalletDependencies,
-  UtxoRepository
-} from '../src';
-
-describe('Wallet', () => {
-  const name = 'Test Wallet';
-  let csl: CardanoSerializationLib;
-  let inputSelector: InputSelector;
-  let keyManager: KeyManagement.KeyManager;
-  let provider: ProviderStub;
-  let utxoRepository: UtxoRepository;
-  let walletDependencies: SingleAddressWalletDependencies;
-
-  beforeEach(async () => {
-    csl = await loadCardanoSerializationLib();
-    keyManager = KeyManagement.createInMemoryKeyManager({
-      csl,
-      mnemonicWords: KeyManagement.util.generateMnemonicWords(),
-      networkId: Cardano.NetworkId.testnet,
-      password: '123'
-    });
-    provider = providerStub();
-    inputSelector = roundRobinRandomImprove(csl);
-    utxoRepository = new InMemoryUtxoRepository({ csl, provider, keyManager, inputSelector, txTracker });
-    walletDependencies = { csl, keyManager, provider, utxoRepository, txTracker };
-  });
-
-  test('createWallet', async () => {
-    const wallet = await createSingleAddressWallet({ name }, walletDependencies);
-    expect(wallet.address).toBeDefined();
-    expect(wallet.name).toBe(name);
-    expect(typeof wallet.initializeTx).toBe('function');
-    expect(typeof wallet.signTx).toBe('function');
-    expect(wallet.balance).toBeInstanceOf(BalanceTracker);
-  });
-
-  describe('wallet behaviour', () => {
-    let wallet: SingleAddressWallet;
-    const props = {
-      outputs: new Set([
-        {
-          address:
-            'addr_test1qpu5vlrf4xkxv2qpwngf6cjhtw542ayty80v8dyr49rf5ewvxwdrt70qlcpeeagscasafhffqsxy36t90ldv06wqrk2qum8x5w',
-          value: { coins: 11_111_111 }
-        }
-      ])
-    };
-
-    beforeEach(async () => {
-      wallet = await createSingleAddressWallet({ name }, walletDependencies);
-    });
-
-    test('initializeTx', async () => {
-      const txInternals = await wallet.initializeTx(props);
-      expect(txInternals.body).toBeInstanceOf(csl.TransactionBody);
-      expect(txInternals.hash).toBeInstanceOf(csl.TransactionHash);
-    });
-
-    test('signTx', async () => {
-      const { body, hash } = await wallet.initializeTx(props);
-      const tx = await wallet.signTx(body, hash);
-      await expect(tx.body().outputs().len()).toBe(2);
-      await expect(tx.body().inputs().len()).toBeGreaterThan(0);
-    });
-
-    test('submitTx', async () => {
-      const { body, hash } = await wallet.initializeTx(props);
-      const tx = await wallet.signTx(body, hash);
-      const { submitted, confirmed } = wallet.submitTx(tx);
-      await confirmed;
-      expect(provider.submitTx).toBeCalledTimes(1);
-      expect(provider.submitTx).toBeCalledWith(tx);
-      expect(txTracker.track).toBeCalledTimes(1);
-      expect(txTracker.track).toBeCalledWith(tx, submitted);
-    });
-  });
-});

package/test/Transaction/CertificateFactory.test.ts

@@ -1,89 +0,0 @@
-import { CardanoSerializationLib, loadCardanoSerializationLib } from '@cardano-sdk/core';
-import { testKeyManager } from '../mocks';
-import { CertificateFactory } from '../../src/Transaction';
-import { KeyManager } from '../../src/KeyManagement';
-
-describe('Transaction.CertificateFactory', () => {
-  let csl: CardanoSerializationLib;
-  let stakeKey: string;
-  let keyManager: KeyManager;
-  let certs: CertificateFactory;
-  const delegatee = 'pool1qqvukkkfr3ux4qylfkrky23f6trl2l6xjluv36z90ax7gfa8yxt';
-
-  beforeAll(async () => {
-    csl = await loadCardanoSerializationLib();
-    keyManager = testKeyManager(csl);
-    stakeKey = keyManager.stakeKey.hash().to_bech32('ed25519_pk');
-    certs = new CertificateFactory(csl, keyManager);
-  });
-
-  it('stakeKeyRegistration', () =>
-    expect(
-      certs.stakeKeyRegistration().as_stake_registration()?.stake_credential().to_keyhash()?.to_bech32('ed25519_pk')
-    ).toBe(stakeKey));
-
-  it('stakeKeyDeregistration', () =>
-    expect(
-      certs.stakeKeyDeregistration().as_stake_deregistration()?.stake_credential().to_keyhash()?.to_bech32('ed25519_pk')
-    ).toBe(stakeKey));
-
-  it('stakeDelegation', () => {
-    const delegation = certs.stakeDelegation(delegatee).as_stake_delegation()!;
-    expect(delegation.stake_credential().to_keyhash()?.to_bech32('ed25519_pk')).toBe(stakeKey);
-    expect(delegation.pool_keyhash().to_bech32('pool')).toBe(delegatee);
-  });
-
-  it('poolRegistration', () => {
-    const owner = keyManager.publicKey.hash().to_bech32('ed25519_pk');
-    const vrfKeyHash = 'vrf_vk13hg4gg5fg67399nuz2ldk89kqw9h379cfgtkpvd83ra89f908kcqv2cw3j';
-    const rewardAddress = 'addr1uxa5pudxg77g3sdaddecmw8tvc6hmynywn49lltt4fmvn7cmpqcax';
-    const poolMetadata = {
-      hash: 'pool1ntpzzu5g6xhqkns4csd435lqtgfjqm7e4wquk9v58eqhf0esey9st6vf29',
-      url: 'https://example.com'
-    };
-    const params = certs
-      .poolRegistration({
-        cost: 1000n,
-        pledge: 10_000n,
-        margin: { denominator: 5, numerator: 1 },
-        owners: [owner],
-        poolKeyHash: stakeKey,
-        relays: [
-          { relayType: 'singlehost-name', hostname: 'example.com', port: 5000 },
-          {
-            relayType: 'singlehost-addr',
-            port: 6000,
-            ipv4: '127.0.0.1'
-          },
-          { relayType: 'multihost-name', dnsName: 'example.com' }
-        ],
-        vrfKeyHash,
-        rewardAddress,
-        poolMetadata
-      })
-      .as_pool_registration()!
-      .pool_params();
-    expect(params.cost().to_str()).toBe('1000');
-    expect(params.pledge().to_str()).toBe('10000');
-    const margin = params.margin();
-    expect(margin.numerator().to_str()).toBe('1');
-    expect(margin.denominator().to_str()).toBe('5');
-    const owners = params.pool_owners();
-    expect(owners.len()).toBe(1);
-    expect(owners.get(0).to_bech32('ed25519_pk')).toBe(owner);
-    expect(params.operator().to_bech32('ed25519_pk')).toBe(stakeKey);
-    const relays = params.relays();
-    expect(relays.len()).toBe(3);
-    expect(params.vrf_keyhash().to_bech32('vrf_vk')).toBe(vrfKeyHash);
-    expect(params.reward_account().to_address().to_bech32('addr')).toBe(rewardAddress);
-    const metadata = params.pool_metadata()!;
-    expect(metadata.url().url()).toBe(poolMetadata.url);
-    expect(metadata.pool_metadata_hash().to_bech32('pool')).toBe(poolMetadata.hash);
-  });
-
-  it('poolRetirement', () => {
-    const retirement = certs.poolRetirement(stakeKey, 1000).as_pool_retirement()!;
-    expect(retirement.pool_keyhash().to_bech32('ed25519_pk')).toEqual(stakeKey);
-    expect(retirement.epoch()).toEqual(1000);
-  });
-});

package/test/Transaction/computeImplicitCoin.test.ts

@@ -1,26 +0,0 @@
-import { loadCardanoSerializationLib, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { testKeyManager } from '../mocks';
-import { Transaction } from '../../src';
-import { InitializeTxProps } from '../../src/Transaction';
-
-describe('Transaction.computeImplicitCoin', () => {
-  it('sums registrations for deposit, withdrawals and deregistrations for input', async () => {
-    const protocolParameters = { stakeKeyDeposit: 2, poolDeposit: 3 } as ProtocolParametersRequiredByWallet;
-    const csl = await loadCardanoSerializationLib();
-    const keyManager = testKeyManager(csl);
-    const certs = new Transaction.CertificateFactory(csl, keyManager);
-    const certificates = [
-      certs.stakeKeyRegistration(),
-      certs.stakeKeyDeregistration(),
-      certs.stakeKeyRegistration(),
-      certs.poolRetirement(keyManager.stakeKey.hash().to_bech32('key'), 1000),
-      certs.stakeDelegation('pool1qqvukkkfr3ux4qylfkrky23f6trl2l6xjluv36z90ax7gfa8yxt')
-    ];
-    const withdrawals = [Transaction.withdrawal(csl, keyManager, 5n)];
-    const txProps = { certificates, withdrawals } as unknown as InitializeTxProps;
-
-    const coin = Transaction.computeImplicitCoin(protocolParameters, txProps);
-    expect(coin.deposit).toBe(2n + 2n);
-    expect(coin.input).toBe(2n + 3n + 5n);
-  });
-});

package/test/Transaction/createTransactionInternals.test.ts

@@ -1,84 +0,0 @@
-import { InputSelector, roundRobinRandomImprove } from '@cardano-sdk/cip2';
-import { loadCardanoSerializationLib, CardanoSerializationLib, CSL, CardanoProvider, Ogmios } from '@cardano-sdk/core';
-import { SelectionConstraints } from '@cardano-sdk/util-dev';
-import { providerStub, txTracker, testKeyManager } from '../mocks';
-import {
-  CertificateFactory,
-  createTransactionInternals,
-  CreateTxInternalsProps,
-  Withdrawal
-} from '../../src/Transaction';
-import { UtxoRepository, InMemoryUtxoRepository, KeyManagement } from '../../src';
-
-const address =
-  'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g';
-
-describe('Transaction.createTransactionInternals', () => {
-  let csl: CardanoSerializationLib;
-  let provider: CardanoProvider;
-  let inputSelector: InputSelector;
-  let utxoRepository: UtxoRepository;
-  let keyManager: KeyManagement.KeyManager;
-  let outputs: Set<CSL.TransactionOutput>;
-
-  const createSimpleTransactionInternals = async (props?: Partial<CreateTxInternalsProps>) => {
-    const result = await utxoRepository.selectInputs(outputs, SelectionConstraints.NO_CONSTRAINTS);
-    const ledgerTip = await provider.ledgerTip();
-    return await createTransactionInternals(csl, {
-      changeAddress: 'addr_test1gz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzerspqgpsqe70et',
-      inputSelection: result.selection,
-      validityInterval: {
-        invalidHereafter: ledgerTip.slot + 3600
-      },
-      ...props
-    });
-  };
-
-  beforeEach(async () => {
-    csl = await loadCardanoSerializationLib();
-    provider = providerStub();
-    inputSelector = roundRobinRandomImprove(csl);
-    keyManager = testKeyManager(csl);
-
-    outputs = new Set([
-      Ogmios.ogmiosToCsl(csl).txOut({
-        address,
-        value: { coins: 4_000_000 }
-      }),
-      Ogmios.ogmiosToCsl(csl).txOut({
-        address,
-        value: { coins: 2_000_000 }
-      })
-    ]);
-    utxoRepository = new InMemoryUtxoRepository({ csl, provider, keyManager, inputSelector, txTracker });
-  });
-
-  test('simple transaction', async () => {
-    const { body, hash } = await createSimpleTransactionInternals();
-    expect(body).toBeInstanceOf(csl.TransactionBody);
-    expect(hash).toBeInstanceOf(csl.TransactionHash);
-  });
-
-  test('transaction with withdrawals', async () => {
-    const withdrawal: Withdrawal = {
-      address: csl.RewardAddress.new(
-        csl.NetworkId.testnet().kind(),
-        csl.StakeCredential.from_keyhash(keyManager.stakeKey.hash())
-      ),
-      quantity: csl.BigNum.from_str('5000000')
-    };
-    const { body } = await createSimpleTransactionInternals({ withdrawals: [withdrawal] });
-    const txWithdrawals = body.withdrawals()!;
-    expect(txWithdrawals.len()).toBe(1);
-    const txWithdrawalQty = txWithdrawals.get(withdrawal.address);
-    expect(txWithdrawalQty?.to_str()).toBe(withdrawal.quantity.to_str());
-  });
-
-  test('transaction with certificates', async () => {
-    const delegatee = 'pool1qqvukkkfr3ux4qylfkrky23f6trl2l6xjluv36z90ax7gfa8yxt';
-    const certFactory = new CertificateFactory(csl, keyManager);
-    const certificates = [certFactory.stakeKeyRegistration(), certFactory.stakeDelegation(delegatee)];
-    const { body } = await createSimpleTransactionInternals({ certificates });
-    expect(body.certs()!.len()).toBe(certificates.length);
-  });
-});