@cardano-sdk/wallet 0.1.4 → 0.1.8

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

package/test/Transaction/withdrawal.test.ts

@@ -1,13 +0,0 @@
-import { loadCardanoSerializationLib } from '@cardano-sdk/core';
-import { testKeyManager } from '../mocks';
-import { Transaction } from '../../src';
-
-describe('Transaction.withdrawal', () => {
-  it('creates objects of correct types', async () => {
-    const csl = await loadCardanoSerializationLib();
-    const keyManager = await testKeyManager(csl);
-    const withdrawal = Transaction.withdrawal(csl, keyManager, 5000n);
-    expect(withdrawal.address).toBeInstanceOf(csl.RewardAddress);
-    expect(withdrawal.quantity).toBeInstanceOf(csl.BigNum);
-  });
-});

package/test/integration/withdrawal.test.ts

@@ -1,108 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { roundRobinRandomImprove } from '@cardano-sdk/cip2';
-import { Cardano, CardanoSerializationLib, loadCardanoSerializationLib } from '@cardano-sdk/core';
-import {
-  BalanceTrackerEvent,
-  createSingleAddressWallet,
-  InMemoryTransactionTracker,
-  InMemoryUtxoRepository,
-  KeyManagement,
-  SingleAddressWallet,
-  SingleAddressWalletProps,
-  Transaction,
-  TransactionError,
-  TransactionFailure,
-  TransactionTracker,
-  UtxoRepository,
-  UtxoRepositoryEvent
-} from '@cardano-sdk/wallet';
-// Not testing with a real provider
-import { providerStub } from '../mocks';
-
-const walletProps: SingleAddressWalletProps = { name: 'some-wallet' };
-const networkId = Cardano.NetworkId.mainnet;
-const mnemonicWords = KeyManagement.util.generateMnemonicWords();
-const password = 'your_password';
-
-describe('integration/withdrawal', () => {
-  let csl: CardanoSerializationLib;
-  let keyManager: KeyManagement.KeyManager;
-  let txTracker: TransactionTracker;
-  let utxoRepository: UtxoRepository;
-  let wallet: SingleAddressWallet;
-
-  beforeAll(async () => {
-    csl = await loadCardanoSerializationLib();
-    keyManager = KeyManagement.createInMemoryKeyManager({ csl, mnemonicWords, password, networkId });
-    const provider = providerStub();
-    const inputSelector = roundRobinRandomImprove(csl);
-    txTracker = new InMemoryTransactionTracker({ csl, provider, pollInterval: 1 });
-    utxoRepository = new InMemoryUtxoRepository({ csl, provider, txTracker, inputSelector, keyManager });
-    wallet = await createSingleAddressWallet(walletProps, {
-      csl,
-      keyManager,
-      provider,
-      utxoRepository,
-      txTracker
-    });
-
-    // Call this to sync available balance
-    await utxoRepository.sync();
-  });
-
-  it('has balance', () => {
-    expect(wallet.balance.total).toBeTruthy();
-    expect(wallet.balance.available).toBeTruthy();
-  });
-
-  it('has events', () => {
-    wallet.balance.on(BalanceTrackerEvent.Changed, ({ total, available }) => {
-      expect(total).toBeTruthy();
-      expect(available).toBeTruthy();
-      // This is emitted after transaction is submitted and balance is locked before confirmation
-      // And after UtxoRepository.sync()
-    });
-    utxoRepository.on(UtxoRepositoryEvent.OutOfSync, () => {
-      // This is emitted when cardano-js-sdk calls sync() internally and it fails.
-      // User should attempt to resync using utxoRepository.sync()
-    });
-  });
-
-  it('can submit transaction', async () => {
-    const certFactory = new Transaction.CertificateFactory(csl, keyManager);
-
-    const { body, hash } = await wallet.initializeTx({
-      certificates: [certFactory.stakeKeyDeregistration()],
-      withdrawals: [Transaction.withdrawal(csl, keyManager, utxoRepository.availableRewards || 0n)],
-      outputs: new Set() // In a real transaction you would probably want to have some outputs
-    });
-    // Calculated fee is returned by invoking body.fee()
-    const tx = await wallet.signTx(body, hash);
-
-    const { submitted, confirmed } = wallet.submitTx(tx);
-    try {
-      // Transaction is submitting. UTxO is locked.
-      await submitted;
-      // Transaction is successfully submitted, but not confirmed yet
-      await confirmed;
-    } catch (error) {
-      if (error instanceof TransactionError) {
-        switch (error.reason) {
-          case TransactionFailure.InvalidTransaction:
-          // Invalid transaction, probably no validity interval set
-          case TransactionFailure.Timeout:
-          // Transaction has expired and will not be confirmed. Therefore it's safe to spend the UTxO again.
-          case TransactionFailure.FailedToSubmit:
-          // Probably attempt to resubmit
-          case TransactionFailure.CannotTrack:
-          // Failed when attempting to track transaction confirmation.
-          // Probably just attempt to track it again by calling txTracker.track(tx)
-          case TransactionFailure.Unknown:
-          // Most likely a bug in cardano-js-sdk
-        }
-      } else {
-        // Most likely a bug in cardano-js-sdk
-      }
-    }
-  });
-});

package/test/mocks/MockTransactionTracker.ts

@@ -1,8 +0,0 @@
-import Emittery from 'emittery';
-import { TransactionTrackerEvents } from '../../src';
-
-export class MockTransactionTracker extends Emittery<TransactionTrackerEvents> {
-  track = jest.fn();
-}
-
-export const txTracker = new MockTransactionTracker();

package/test/mocks/MockUtxoRepository.ts

@@ -1,13 +0,0 @@
-import Emittery from 'emittery';
-import { delegate, rewards, utxo } from './ProviderStub';
-import { UtxoRepository, UtxoRepositoryEvents } from '../../src';
-
-export class MockUtxoRepository extends Emittery<UtxoRepositoryEvents> implements UtxoRepository {
-  sync = jest.fn().mockResolvedValue(void 0);
-  selectInputs = jest.fn();
-  allUtxos = utxo;
-  availableUtxos = utxo;
-  allRewards = rewards;
-  availableRewards = rewards;
-  delegation = delegate;
-}

package/test/mocks/ProviderStub.ts

@@ -1,151 +0,0 @@
-/* eslint-disable max-len */
-import * as Schema from '@cardano-ogmios/schema';
-import { PXL, TSLA } from '@cardano-sdk/util-dev/src/assetId';
-
-export const stakeKeyHash = 'stake_test1up7pvfq8zn4quy45r2g572290p9vf99mr9tn7r9xrgy2l2qdsf58d';
-
-export const utxo: Schema.Utxo = [
-  [
-    {
-      txId: 'bb217abaca60fc0ca68c1555eca6a96d2478547818ae76ce6836133f3cc546e0',
-      index: 1
-    },
-    {
-      address:
-        'addr_test1qzs0umu0s2ammmpw0hea0w2crtcymdjvvlqngpgqy76gpfnuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475qp3y3vz',
-      value: {
-        coins: 4_027_026_465,
-        assets: {
-          [TSLA]: 10n,
-          [PXL]: 5n
-        }
-      },
-      datum: null
-    }
-  ],
-  [
-    {
-      txId: 'c7c0973c6bbf1a04a9f306da7814b4fa564db649bf48b0bd93c273bd03143547',
-      index: 0
-    },
-    {
-      address:
-        'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g',
-      value: {
-        coins: 3_289_566,
-        assets: {
-          [TSLA]: 15n
-        }
-      },
-      datum: null
-    }
-  ],
-  [
-    {
-      txId: 'ea1517b8c36fea3148df9aa1f49bbee66ff59a5092331a67bd8b3c427e1d79d7',
-      index: 2
-    },
-    {
-      address:
-        'addr_test1qqydn46r6mhge0kfpqmt36m6q43knzsd9ga32n96m89px3nuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475qypp3m9',
-      value: {
-        coins: 9_825_963
-      },
-      datum: null
-    }
-  ]
-];
-
-export const delegate = 'pool185g59xpqzt7gf0ljr8v8f3akl95qnmardf2f8auwr3ffx7atjj5';
-export const rewards = 33_333n;
-export const delegationAndRewards = { delegate, rewards };
-
-export const queryTransactionsResult = [
-  {
-    hash: 'ea1517b8c36fea3148df9aa1f49bbee66ff59a5092331a67bd8b3c427e1d79d7',
-    inputs: [
-      {
-        txId: 'bb217abaca60fc0ca68c1555eca6a96d2478547818ae76ce6836133f3cc546e0',
-        index: 0
-      }
-    ],
-    outputs: [
-      {
-        address:
-          'addr_test1qpfhhfy2qgls50r9u4yh0l7z67xpg0a5rrhkmvzcuqrd0znuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q9gw0lz',
-        value: { coins: 5_000_000 }
-      },
-      {
-        address:
-          'addr_test1qplfzem2xsc29wxysf8wkdqrm4s4mmncd40qnjq9sk84l3tuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q52ukj5',
-        value: { coins: 5_000_000 }
-      },
-      {
-        address:
-          'addr_test1qqydn46r6mhge0kfpqmt36m6q43knzsd9ga32n96m89px3nuzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475qypp3m9',
-        value: { coins: 9_825_963 }
-      }
-    ]
-  }
-];
-const queryTransactions = () => jest.fn().mockResolvedValue(queryTransactionsResult);
-
-export const ledgerTip = {
-  blockNo: 1_111_111,
-  hash: '10d64cc11e9b20e15b6c46aa7b1fed11246f437e62225655a30ea47bf8cc22d0',
-  slot: 37_834_496
-};
-
-/**
- * Provider stub for testing
- *
- * returns CardanoProvider-compatible object
- */
-export const providerStub = () => ({
-  ledgerTip: jest.fn().mockResolvedValue(ledgerTip),
-  networkInfo: async () => ({
-    currentEpoch: {
-      number: 158,
-      start: {
-        date: new Date(1_632_255_616)
-      },
-      end: {
-        date: new Date(1_632_687_616)
-      }
-    },
-    lovelaceSupply: {
-      circulating: 42_064_399_450_423_723n,
-      max: 45_000_000_000_000_000n,
-      total: 40_267_211_394_073_980n
-    },
-    stake: {
-      active: 1_060_378_314_781_343n,
-      live: 15_001_884_895_856_815n
-    }
-  }),
-  submitTx: jest.fn().mockResolvedValue(void 0),
-  stakePoolStats: async () => ({
-    qty: {
-      active: 1000,
-      retired: 500,
-      retiring: 5
-    }
-  }),
-  utxoDelegationAndRewards: jest.fn().mockResolvedValue({ utxo, delegationAndRewards }),
-  queryTransactionsByAddresses: queryTransactions(),
-  queryTransactionsByHashes: queryTransactions(),
-  currentWalletProtocolParameters: async () => ({
-    minFeeCoefficient: 44,
-    minFeeConstant: 155_381,
-    stakeKeyDeposit: 2_000_000,
-    poolDeposit: 500_000_000,
-    protocolVersion: { major: 5, minor: 0 },
-    minPoolCost: 340_000_000,
-    maxTxSize: 16_384,
-    maxValueSize: 1000,
-    maxCollateralInputs: 1,
-    coinsPerUtxoWord: 34_482
-  })
-});
-
-export type ProviderStub = ReturnType<typeof providerStub>;

package/test/mocks/index.ts

@@ -1,4 +0,0 @@
-export * from './ProviderStub';
-export * from './MockUtxoRepository';
-export * from './MockTransactionTracker';
-export * from './testKeyManager';

package/test/mocks/testKeyManager.ts

@@ -1,10 +0,0 @@
-import { Cardano, CardanoSerializationLib } from '@cardano-sdk/core';
-import { KeyManagement } from '../../src';
-
-export const testKeyManager = (csl: CardanoSerializationLib) =>
-  KeyManagement.createInMemoryKeyManager({
-    csl,
-    mnemonicWords: KeyManagement.util.generateMnemonicWords(),
-    password: '',
-    networkId: Cardano.NetworkId.testnet
-  });

package/test/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": "."
-  },
-  "references": [
-    { "path": "../src" },
-    { "path": "../../util-dev/src" },
-    { "path": "../../cip2/src" },
-    { "path": "../../core/src" }
-  ]
-}