@cardano-sdk/wallet 0.1.4 → 0.1.8

package/src/Transaction/withdrawal.ts

@@ -1,17 +0,0 @@
-import { Cardano, CardanoSerializationLib, CSL, Ogmios } from '@cardano-sdk/core';
-import { KeyManager } from '../KeyManagement';
-
-export type Withdrawal = {
-  address: CSL.RewardAddress;
-  quantity: CSL.BigNum;
-};
-
-export const withdrawal = (
-  csl: CardanoSerializationLib,
-  keyManager: KeyManager,
-  quantity: Ogmios.Lovelace,
-  network: number = Cardano.NetworkId.mainnet
-): Withdrawal => ({
-  address: csl.RewardAddress.new(network, csl.StakeCredential.from_keyhash(keyManager.stakeKey.hash())),
-  quantity: csl.BigNum.from_str(quantity.toString())
-});

package/src/TransactionError.ts

@@ -1,17 +0,0 @@
-import { CustomError } from 'ts-custom-error';
-
-export enum TransactionFailure {
-  InvalidTransaction = 'INVALID_TRANSACTION',
-  FailedToSubmit = 'FAILED_TO_SUBMIT',
-  Unknown = 'UNKNOWN',
-  CannotTrack = 'CANNOT_TRACK',
-  Timeout = 'TIMEOUT'
-}
-
-const formatDetail = (detail?: string) => (detail ? ` (${detail})` : '');
-
-export class TransactionError extends CustomError {
-  constructor(public reason: TransactionFailure, public innerError?: unknown, public detail?: string) {
-    super(`Transaction failed: ${reason}${formatDetail(detail)}`);
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-export * as Address from './Address';
-export * as Transaction from './Transaction';
-export * from './InMemoryUtxoRepository';
-export * from './InMemoryTransactionTracker';
-export * as KeyManagement from './KeyManagement';
-export * from './SingleAddressWallet';
-export * from './types';
-export * from './TransactionError';
-export * from './BalanceTracker';

package/src/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../dist/",
-    "rootDir": "."
-  },
-  "references": [
-    { "path": "../../cip2/src" },
-    { "path": "../../core/src" }
-  ]
-}

package/src/types.ts

@@ -1,56 +0,0 @@
-import Schema from '@cardano-ogmios/schema';
-import { ImplicitCoin, SelectionConstraints, SelectionResult } from '@cardano-sdk/cip2';
-import { CSL, Ogmios } from '@cardano-sdk/core';
-import Emittery from 'emittery';
-
-export enum UtxoRepositoryEvent {
-  Changed = 'changed',
-  OutOfSync = 'out-of-sync'
-}
-
-export interface UtxoRepositoryFields {
-  allUtxos: Schema.Utxo;
-  availableUtxos: Schema.Utxo;
-  allRewards: Ogmios.Lovelace | null;
-  availableRewards: Ogmios.Lovelace | null;
-  delegation: Schema.PoolId | null;
-}
-
-export type UtxoRepositoryEvents = {
-  changed: UtxoRepositoryFields;
-  'out-of-sync': void;
-  'transaction-untracked': CSL.Transaction;
-};
-export type UtxoRepository = {
-  sync: () => Promise<void>;
-  selectInputs: (
-    outputs: Set<CSL.TransactionOutput>,
-    constraints: SelectionConstraints,
-    implicitCoin?: ImplicitCoin
-  ) => Promise<SelectionResult>;
-} & UtxoRepositoryFields &
-  Emittery<UtxoRepositoryEvents>;
-
-export interface OnTransactionArgs {
-  transaction: CSL.Transaction;
-  /**
-   * Resolves when transaction is confirmed.
-   * Rejects if transaction fails to submit or validate.
-   */
-  confirmed: Promise<void>;
-}
-
-export enum TransactionTrackerEvent {
-  NewTransaction = 'new-transaction'
-}
-
-export type TransactionTrackerEvents = { 'new-transaction': OnTransactionArgs };
-export interface TransactionTracker extends Emittery<TransactionTrackerEvents> {
-  /**
-   * Track a new transaction.
-   *
-   * @param {CSL.Transaction} transaction transaction to track.
-   * @param {Promise<void>} submitted defer checking for transaction confirmation until this resolves.
-   */
-  track(transaction: CSL.Transaction, submitted?: Promise<void>): Promise<void>;
-}

package/test/.eslintrc.js

@@ -1,7 +0,0 @@
-module.exports = {
-  "extends": ["../../../test/.eslintrc.js"],
-  "parserOptions": {
-    "project": "./tsconfig.json",
-    "tsconfigRootDir": __dirname
-  }
-}

package/test/BalanceTracker.test.ts

@@ -1,44 +0,0 @@
-import { Ogmios } from '@cardano-sdk/core';
-import { MockUtxoRepository } from './mocks';
-import { BalanceTracker, UtxoRepositoryEvent, UtxoRepositoryFields } from '../src';
-
-const numAssets = (tokenMap?: Ogmios.TokenMap) => Object.keys(tokenMap || {}).length;
-
-describe('BalanceTracker', () => {
-  let balanceTracker: BalanceTracker;
-  let utxoRepository: MockUtxoRepository;
-
-  beforeEach(() => {
-    utxoRepository = new MockUtxoRepository();
-    balanceTracker = new BalanceTracker(utxoRepository);
-  });
-
-  it('constructor sets balances from utxo repository', () => {
-    expect(balanceTracker.total.coins).toBeGreaterThan(0n);
-    expect(balanceTracker.total.assets).toBeTruthy();
-    expect(balanceTracker.total.rewards).toBeGreaterThan(0n);
-  });
-
-  it('updates balances on UtxoRepositoryEvent.Changed', async () => {
-    const totalBefore = balanceTracker.total;
-
-    const allRewards = utxoRepository.allRewards - 1n;
-    const availableRewards = utxoRepository.allRewards - 2n;
-    await utxoRepository.emit(UtxoRepositoryEvent.Changed, {
-      allUtxos: utxoRepository.allUtxos.slice(1),
-      availableUtxos: utxoRepository.allUtxos.slice(2),
-      allRewards,
-      availableRewards,
-      delegation: null
-    } as UtxoRepositoryFields);
-
-    expect(balanceTracker.total.coins).toBeLessThan(totalBefore.coins);
-    expect(balanceTracker.total.coins).toBeGreaterThan(balanceTracker.available.coins);
-
-    expect(numAssets(balanceTracker.total.assets)).toBeLessThan(numAssets(totalBefore.assets));
-    expect(numAssets(balanceTracker.total.assets)).toBeGreaterThan(numAssets(balanceTracker.available.assets));
-
-    expect(balanceTracker.total.rewards).toBe(allRewards);
-    expect(balanceTracker.available.rewards).toBe(availableRewards);
-  });
-});

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);
-    });
-  });
-});