@cardano-sdk/wallet 0.1.4 → 0.1.5

package/src/KeyManagement/InMemoryKeyManager.ts

@@ -1,67 +0,0 @@
-import * as bip39 from 'isomorphic-bip39';
-import { Cardano, CardanoSerializationLib, CSL } from '@cardano-sdk/core';
-import { Buffer } from 'buffer';
-import * as errors from './errors';
-import { KeyManager } from './types';
-import { harden, joinMnemonicWords } from './util';
-
-export const createInMemoryKeyManager = ({
-  csl,
-  password,
-  accountIndex,
-  mnemonicWords,
-  networkId
-}: {
-  csl: CardanoSerializationLib;
-  password: string;
-  accountIndex?: number;
-  mnemonicWords: string[];
-  networkId: Cardano.NetworkId;
-}): KeyManager => {
-  if (!accountIndex) {
-    accountIndex = 0;
-  }
-
-  const mnemonic = joinMnemonicWords(mnemonicWords);
-  const validMnemonic = bip39.validateMnemonic(mnemonic);
-  if (!validMnemonic) throw new errors.InvalidMnemonic();
-
-  const entropy = bip39.mnemonicToEntropy(mnemonic);
-  const accountPrivateKey = csl.Bip32PrivateKey.from_bip39_entropy(Buffer.from(entropy, 'hex'), Buffer.from(password))
-    .derive(harden(1852))
-    .derive(harden(1815))
-    .derive(harden(accountIndex));
-
-  const privateParentKey = accountPrivateKey.derive(0).derive(0);
-  const publicParentKey = privateParentKey.to_public();
-  const publicKey = accountPrivateKey.to_public();
-  const stakeKey = publicKey.derive(2).derive(0);
-
-  return {
-    deriveAddress: (addressIndex, index) => {
-      const utxoPubKey = publicKey.derive(index).derive(addressIndex);
-      const baseAddr = csl.BaseAddress.new(
-        networkId,
-        csl.StakeCredential.from_keyhash(utxoPubKey.to_raw_key().hash()),
-        csl.StakeCredential.from_keyhash(stakeKey.to_raw_key().hash())
-      );
-
-      return baseAddr.to_address().to_bech32();
-    },
-    signMessage: async (_addressType, _signingIndex, message) => ({
-      publicKey: publicParentKey.toString(),
-      signature: `Signature for ${message} is not implemented yet`
-    }),
-    signTransaction: async (txHash: CSL.TransactionHash) => {
-      const witnessSet = csl.TransactionWitnessSet.new();
-      const vkeyWitnesses = csl.Vkeywitnesses.new();
-      const vkeyWitness = csl.make_vkey_witness(txHash, privateParentKey.to_raw_key());
-      vkeyWitnesses.add(vkeyWitness);
-      witnessSet.set_vkeys(vkeyWitnesses);
-      return witnessSet;
-    },
-    stakeKey: stakeKey.to_raw_key(),
-    publicKey: publicKey.to_raw_key(),
-    publicParentKey: publicParentKey.to_raw_key()
-  };
-};

package/src/KeyManagement/errors/InvalidMnemonic.ts

@@ -1,9 +0,0 @@
-import { CustomError } from 'ts-custom-error';
-
-export class InvalidMnemonic extends CustomError {
-  constructor() {
-    super();
-    this.message = 'Invalid Mnemonic';
-    this.name = 'InvalidMnemonic';
-  }
-}

package/src/KeyManagement/types.ts

@@ -1,15 +0,0 @@
-import { CSL } from '@cardano-sdk/core';
-import { Address } from '..';
-
-export interface KeyManager {
-  deriveAddress: (addressIndex: number, index: 0 | 1) => string;
-  signMessage: (
-    addressType: Address.AddressType,
-    signingIndex: number,
-    message: string
-  ) => Promise<{ publicKey: string; signature: string }>;
-  publicKey: CSL.PublicKey;
-  publicParentKey: CSL.PublicKey;
-  signTransaction: (txHash: CSL.TransactionHash) => Promise<CSL.TransactionWitnessSet>;
-  stakeKey: CSL.PublicKey;
-}

package/src/KeyManagement/util.ts

@@ -1,14 +0,0 @@
-import * as bip39 from 'isomorphic-bip39';
-
-/**
- * A wrapper around the bip39 package function, with default strength applied to produce 24 words
- */
-export const generateMnemonicWords = (strength = 256) => bip39.generateMnemonic(strength).split(' ');
-export const joinMnemonicWords = (mnenomic: string[]) => mnenomic.join(' ');
-
-/**
- * A wrapper around the bip39 package function
- */
-export const validateMnemonic = bip39.validateMnemonic;
-
-export const harden = (num: number): number => 0x80_00_00_00 + num;

package/src/SingleAddressWallet.ts

@@ -1,120 +0,0 @@
-import Schema from '@cardano-ogmios/schema';
-import { CardanoProvider, Ogmios, Transaction, CardanoSerializationLib, CSL, ProviderError } from '@cardano-sdk/core';
-import { UtxoRepository } from './types';
-import { dummyLogger, Logger } from 'ts-log';
-import { defaultSelectionConstraints } from '@cardano-sdk/cip2';
-import { computeImplicitCoin, createTransactionInternals, InitializeTxProps, TxInternals } from './Transaction';
-import {
-  BalanceTracker,
-  InMemoryTransactionTracker,
-  KeyManagement,
-  TransactionError,
-  TransactionFailure,
-  TransactionTracker
-} from '.';
-
-export interface SubmitTxResult {
-  /**
-   * Resolves when transaction is submitted.
-   * Rejects with {TransactionError}.
-   */
-  submitted: Promise<void>;
-  /**
-   * Resolves when transaction is submitted and confirmed.
-   * Rejects with {TransactionError}.
-   */
-  confirmed: Promise<void>;
-}
-export interface SingleAddressWallet {
-  address: Schema.Address;
-  balance: BalanceTracker;
-  initializeTx: (props: InitializeTxProps) => Promise<TxInternals>;
-  name: string;
-  signTx: (body: CSL.TransactionBody, hash: CSL.TransactionHash) => Promise<CSL.Transaction>;
-  submitTx: (tx: CSL.Transaction) => SubmitTxResult;
-}
-
-export interface SingleAddressWalletDependencies {
-  csl: CardanoSerializationLib;
-  keyManager: KeyManagement.KeyManager;
-  logger?: Logger;
-  provider: CardanoProvider;
-  utxoRepository: UtxoRepository;
-  txTracker?: TransactionTracker;
-  balanceTracker?: BalanceTracker;
-}
-
-export interface SingleAddressWalletProps {
-  name: string;
-}
-
-const ensureValidityInterval = (
-  currentSlot: number,
-  validityInterval?: Transaction.ValidityInterval
-): Transaction.ValidityInterval =>
-  // Todo: Based this on slot duration, to equal 2hrs
-  ({ invalidHereafter: currentSlot + 3600, ...validityInterval });
-
-export const createSingleAddressWallet = async (
-  { name }: SingleAddressWalletProps,
-  {
-    csl,
-    provider,
-    keyManager,
-    utxoRepository,
-    txTracker = new InMemoryTransactionTracker({ csl, provider }),
-    balanceTracker = new BalanceTracker(utxoRepository),
-    logger = dummyLogger
-  }: SingleAddressWalletDependencies
-): Promise<SingleAddressWallet> => {
-  const address = keyManager.deriveAddress(0, 0);
-  const protocolParameters = await provider.currentWalletProtocolParameters();
-  const signTx = async (body: CSL.TransactionBody, hash: CSL.TransactionHash) => {
-    const witnessSet = await keyManager.signTransaction(hash);
-    return csl.Transaction.new(body, witnessSet);
-  };
-  return {
-    address,
-    balance: balanceTracker,
-    initializeTx: async (props) => {
-      const tip = await provider.ledgerTip();
-      const validityInterval = ensureValidityInterval(tip.slot, props.options?.validityInterval);
-      const txOutputs = new Set([...props.outputs].map((output) => Ogmios.ogmiosToCsl(csl).txOut(output)));
-      const constraints = defaultSelectionConstraints({
-        csl,
-        protocolParameters,
-        buildTx: async (inputSelection) => {
-          logger.debug('Building TX for selection constraints', inputSelection);
-          const { body, hash } = await createTransactionInternals(csl, {
-            changeAddress: address,
-            inputSelection,
-            validityInterval
-          });
-          return signTx(body, hash);
-        }
-      });
-      const implicitCoin = computeImplicitCoin(protocolParameters, props);
-      const inputSelectionResult = await utxoRepository.selectInputs(txOutputs, constraints, implicitCoin);
-      return createTransactionInternals(csl, {
-        changeAddress: address,
-        inputSelection: inputSelectionResult.selection,
-        validityInterval
-      });
-    },
-    name,
-    signTx,
-    submitTx: (tx) => {
-      const submitted = provider.submitTx(tx).catch((error) => {
-        if (error instanceof ProviderError) {
-          throw new TransactionError(TransactionFailure.FailedToSubmit, error, error.detail);
-        }
-        throw new TransactionError(TransactionFailure.FailedToSubmit, error);
-      });
-      const confirmed = txTracker.track(tx, submitted);
-      return {
-        submitted,
-        confirmed
-      };
-    }
-  };
-};

package/src/Transaction/CertificateFactory.ts

@@ -1,154 +0,0 @@
-import { ByName } from '@cardano-ogmios/schema';
-import { CardanoSerializationLib, CSL, NotImplementedError, Ogmios } from '@cardano-sdk/core';
-import { KeyManager } from '../KeyManagement';
-
-export type Ed25519KeyHashBech32 = string;
-export type VrfKeyHashBech32 = string;
-export type AddressBech32 = string;
-export type PoolMetadataHashBech32 = string;
-
-interface Ratio {
-  numerator: number;
-  denominator: number;
-}
-
-interface MultiHostNameRelay {
-  relayType: 'multihost-name';
-  dnsName: string;
-}
-
-type SingleHostAddrRelay = {
-  relayType: 'singlehost-addr';
-  ipv4?: string;
-  ipv6?: string;
-  port?: number;
-};
-
-type SingleHostNameRelay = {
-  relayType: 'singlehost-name';
-} & ByName;
-
-type Relay = MultiHostNameRelay | SingleHostAddrRelay | SingleHostNameRelay;
-
-interface PoolMetadata {
-  hash: PoolMetadataHashBech32;
-  url: string;
-}
-
-interface PoolParameters {
-  poolKeyHash: Ed25519KeyHashBech32;
-  vrfKeyHash: VrfKeyHashBech32;
-  pledge: Ogmios.Lovelace;
-  cost: Ogmios.Lovelace;
-  margin: Ratio;
-  rewardAddress: AddressBech32;
-  owners: Ed25519KeyHashBech32[];
-  relays: Relay[];
-  poolMetadata?: PoolMetadata;
-}
-
-export class CertificateFactory {
-  readonly #stakeCredential: CSL.StakeCredential;
-  readonly #csl: CardanoSerializationLib;
-
-  constructor(csl: CardanoSerializationLib, keyManager: KeyManager) {
-    this.#csl = csl;
-    this.#stakeCredential = csl.StakeCredential.from_keyhash(keyManager.stakeKey.hash());
-  }
-
-  stakeKeyRegistration() {
-    return this.#csl.Certificate.new_stake_registration(this.#csl.StakeRegistration.new(this.#stakeCredential));
-  }
-
-  stakeKeyDeregistration() {
-    return this.#csl.Certificate.new_stake_deregistration(this.#csl.StakeDeregistration.new(this.#stakeCredential));
-  }
-
-  poolRegistration({
-    poolKeyHash,
-    vrfKeyHash,
-    pledge,
-    cost,
-    margin,
-    rewardAddress,
-    owners,
-    relays,
-    poolMetadata
-  }: PoolParameters) {
-    const cslOwners = this.#csl.Ed25519KeyHashes.new();
-    for (const owner of owners) {
-      cslOwners.add(this.#csl.Ed25519KeyHash.from_bech32(owner));
-    }
-    const cslRelays = this.#createCslRelays(relays);
-    const poolParams = this.#csl.PoolParams.new(
-      this.#csl.Ed25519KeyHash.from_bech32(poolKeyHash),
-      this.#csl.VRFKeyHash.from_bech32(vrfKeyHash),
-      this.#csl.BigNum.from_str(pledge.toString()),
-      this.#csl.BigNum.from_str(cost.toString()),
-      this.#csl.UnitInterval.new(
-        this.#csl.BigNum.from_str(margin.numerator.toString()),
-        this.#csl.BigNum.from_str(margin.denominator.toString())
-      ),
-      this.#csl.RewardAddress.from_address(this.#csl.Address.from_bech32(rewardAddress))!,
-      cslOwners,
-      cslRelays,
-      poolMetadata
-        ? this.#csl.PoolMetadata.new(
-            this.#csl.URL.new(poolMetadata.url),
-            this.#csl.PoolMetadataHash.from_bech32(poolMetadata.hash)
-          )
-        : undefined
-    );
-    return this.#csl.Certificate.new_pool_registration(this.#csl.PoolRegistration.new(poolParams));
-  }
-
-  poolRetirement(poolKeyHash: Ed25519KeyHashBech32, epoch: number) {
-    return this.#csl.Certificate.new_pool_retirement(
-      this.#csl.PoolRetirement.new(this.#csl.Ed25519KeyHash.from_bech32(poolKeyHash), epoch)
-    );
-  }
-
-  stakeDelegation(delegatee: Ed25519KeyHashBech32) {
-    return this.#csl.Certificate.new_stake_delegation(
-      this.#csl.StakeDelegation.new(this.#stakeCredential, this.#csl.Ed25519KeyHash.from_bech32(delegatee))
-    );
-  }
-
-  #createCslRelays(relays: Relay[]) {
-    const cslRelays = this.#csl.Relays.new();
-    for (const relay of relays) {
-      switch (relay.relayType) {
-        case 'singlehost-addr':
-          if (relay.ipv6) {
-            throw new NotImplementedError('Parse IPv6 to byte array');
-          }
-          cslRelays.add(
-            this.#csl.Relay.new_single_host_addr(
-              this.#csl.SingleHostAddr.new(
-                relay.port,
-                relay.ipv4
-                  ? this.#csl.Ipv4.new(new Uint8Array(relay.ipv4.split('.').map((segment) => Number.parseInt(segment))))
-                  : undefined
-              )
-            )
-          );
-          break;
-        case 'singlehost-name':
-          cslRelays.add(
-            this.#csl.Relay.new_single_host_name(
-              this.#csl.SingleHostName.new(relay.port || undefined, this.#csl.DNSRecordAorAAAA.new(relay.hostname))
-            )
-          );
-          break;
-        case 'multihost-name':
-          cslRelays.add(
-            this.#csl.Relay.new_multi_host_name(this.#csl.MultiHostName.new(this.#csl.DNSRecordSRV.new(relay.dnsName)))
-          );
-          break;
-        default:
-          throw new NotImplementedError('Relay type');
-      }
-    }
-    return cslRelays;
-  }
-}

package/src/Transaction/computeImplicitCoin.ts

@@ -1,36 +0,0 @@
-import { ImplicitCoin } from '@cardano-sdk/cip2';
-import { BigIntMath, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { InitializeTxProps } from './types';
-
-/**
- * Implementation is the same as in csl.get_implicit_input() and csl.get_deposit().
- */
-export const computeImplicitCoin = (
-  { stakeKeyDeposit, poolDeposit }: ProtocolParametersRequiredByWallet,
-  { certificates, withdrawals }: InitializeTxProps
-): ImplicitCoin => {
-  const stakeKeyDepositBigint = stakeKeyDeposit && BigInt(stakeKeyDeposit);
-  const poolDepositBigint = poolDeposit && BigInt(poolDeposit);
-  const deposit = BigIntMath.sum(
-    certificates?.map(
-      (cert) =>
-        (cert.as_stake_registration() && stakeKeyDepositBigint) ||
-        (cert.as_pool_registration() && poolDepositBigint) ||
-        0n
-    ) || []
-  );
-  const withdrawalsTotal =
-    (withdrawals && BigIntMath.sum(withdrawals.map(({ quantity }) => BigInt(quantity.to_str())))) || 0n;
-  const reclaimTotal = BigIntMath.sum(
-    certificates?.map(
-      (cert) =>
-        (cert.as_stake_deregistration() && stakeKeyDepositBigint) ||
-        (cert.as_pool_retirement() && poolDepositBigint) ||
-        0n
-    ) || []
-  );
-  return {
-    deposit,
-    input: withdrawalsTotal + reclaimTotal
-  };
-};

package/src/Transaction/createTransactionInternals.ts

@@ -1,60 +0,0 @@
-import { SelectionResult } from '@cardano-sdk/cip2';
-import { Transaction, CardanoSerializationLib, CSL } from '@cardano-sdk/core';
-import { Withdrawal } from './withdrawal';
-
-export type TxInternals = {
-  hash: CSL.TransactionHash;
-  body: CSL.TransactionBody;
-};
-
-export type CreateTxInternalsProps = {
-  changeAddress: string;
-  inputSelection: SelectionResult['selection'];
-  validityInterval: Transaction.ValidityInterval;
-  certificates?: CSL.Certificate[];
-  withdrawals?: Withdrawal[];
-};
-
-export const createTransactionInternals = async (
-  csl: CardanoSerializationLib,
-  props: CreateTxInternalsProps
-): Promise<TxInternals> => {
-  const inputs = csl.TransactionInputs.new();
-  for (const utxo of props.inputSelection.inputs) {
-    inputs.add(utxo.input());
-  }
-  const outputs = csl.TransactionOutputs.new();
-  for (const output of props.inputSelection.outputs) {
-    outputs.add(output);
-  }
-  for (const value of props.inputSelection.change) {
-    outputs.add(csl.TransactionOutput.new(csl.Address.from_bech32(props.changeAddress), value));
-  }
-  const body = csl.TransactionBody.new(
-    inputs,
-    outputs,
-    props.inputSelection.fee,
-    props.validityInterval.invalidHereafter
-  );
-  if (props.validityInterval.invalidBefore !== undefined) {
-    body.set_validity_start_interval(props.validityInterval.invalidBefore);
-  }
-  if (props.certificates?.length) {
-    const certs = csl.Certificates.new();
-    for (const cert of props.certificates) {
-      certs.add(cert);
-    }
-    body.set_certs(certs);
-  }
-  if (props.withdrawals?.length) {
-    const withdrawals = csl.Withdrawals.new();
-    for (const { address, quantity } of props.withdrawals) {
-      withdrawals.insert(address, quantity);
-    }
-    body.set_withdrawals(withdrawals);
-  }
-  return {
-    body,
-    hash: csl.hash_transaction(body)
-  };
-};

package/src/Transaction/types.ts

@@ -1,12 +0,0 @@
-import * as Schema from '@cardano-ogmios/schema';
-import { CSL, Transaction } from '@cardano-sdk/core';
-import { Withdrawal } from './withdrawal';
-
-export type InitializeTxProps = {
-  outputs: Set<Schema.TxOut>;
-  certificates?: CSL.Certificate[];
-  withdrawals?: Withdrawal[];
-  options?: {
-    validityInterval?: Transaction.ValidityInterval;
-  };
-};

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