fix(wallet): lock utxo right after submitting, run input selection with availableUtxo set

Author: mkazlauskas

packages/wallet/src/InMemoryTransactionTracker.ts

@@ -30,7 +30,8 @@ export class InMemoryTransactionTracker extends Emittery<TransactionTrackerEvent
     this.#pollInterval = pollInterval;
   }
 
-  async trackTransaction(transaction: CSL.Transaction): Promise<void> {
+  async trackTransaction(transaction: CSL.Transaction, submitted: Promise<void> = Promise.resolve()): Promise<void> {
+    await submitted;
     const body = transaction.body();
     const hash = Buffer.from(this.#csl.hash_transaction(body).to_bytes()).toString('hex');
     this.#logger.debug('InMemoryTransactionTracker.trackTransaction', hash);

packages/wallet/src/InMemoryUtxoRepository.ts

@@ -19,7 +19,6 @@ export interface InMemoryUtxoRepositoryProps {
   logger?: Logger;
 }
 
-// Review: is comparing txIn enough to identify unique utxo?
 const utxoEquals = ([txIn1]: [Schema.TxIn, Schema.TxOut], [txIn2]: [Schema.TxIn, Schema.TxOut]): boolean =>
   txIn1.txId === txIn2.txId && txIn1.index === txIn2.index;
 export class InMemoryUtxoRepository extends Emittery<UtxoRepositoryEvents> implements UtxoRepository {
@@ -93,7 +92,7 @@ export class InMemoryUtxoRepository extends Emittery<UtxoRepositoryEvents> imple
       await this.sync();
     }
     return this.#inputSelector.select({
-      utxo: new Set(Ogmios.ogmiosToCsl(this.#csl).utxo(this.allUtxos)),
+      utxo: new Set(Ogmios.ogmiosToCsl(this.#csl).utxo(this.availableUtxos)),
       outputs,
       constraints,
       implicitCoin

packages/wallet/src/SingleAddressWallet.ts

@@ -1,20 +1,20 @@
 import Schema from '@cardano-ogmios/schema';
-import { CardanoProvider, Ogmios, Transaction, CardanoSerializationLib, CSL } from '@cardano-sdk/core';
+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 { KeyManagement, TransactionTracker } from '.';
+import { KeyManagement, TransactionError, TransactionFailure, TransactionTracker } from '.';
 
 export interface SubmitTxResult {
   /**
    * Resolves when transaction is submitted.
-   * Rejects with ProviderError.
+   * Rejects with {TransactionError}.
    */
   submitted: Promise<void>;
   /**
    * Resolves when transaction is submitted and confirmed.
-   * Rejects with TransactionError.
+   * Rejects with {TransactionError}.
    */
   confirmed: Promise<void>;
 }
@@ -23,12 +23,6 @@ export interface SingleAddressWallet {
   initializeTx: (props: InitializeTxProps) => Promise<TxInternals>;
   name: string;
   signTx: (body: CSL.TransactionBody, hash: CSL.TransactionHash) => Promise<CSL.Transaction>;
-  /**
-   * Submits transaction.
-   *
-   * @returns {Promise<SubmitTxResult>} promise that resolves when transaction is submitted,
-   * but not confirmed yet. Rejects with TransactionError { FailedToSubmit }
-   */
   submitTx: (tx: CSL.Transaction) => SubmitTxResult;
 }
 
@@ -92,10 +86,16 @@ export const createSingleAddressWallet = async (
     name,
     signTx,
     submitTx: (tx) => {
-      const submitted = provider.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.trackTransaction(tx, submitted);
       return {
         submitted,
-        confirmed: submitted.then(() => txTracker.trackTransaction(tx))
+        confirmed
       };
     }
   };

packages/wallet/src/TransactionError.ts

@@ -1,6 +1,8 @@
 import { CustomError } from 'ts-custom-error';
 
 export enum TransactionFailure {
+  FailedToSubmit = 'FAILED_TO_SUBMIT',
+  Unknown = 'UNKNOWN',
   CannotTrack = 'CANNOT_TRACK',
   Timeout = 'TIMEOUT'
 }

packages/wallet/src/types.ts

@@ -30,5 +30,5 @@ export interface TransactionTracker extends Emittery<TransactionTrackerEvents> {
   /**
    * Track a new transaction
    */
-  trackTransaction(transaction: CSL.Transaction): Promise<void>;
+  trackTransaction(transaction: CSL.Transaction, submitted?: Promise<void>): Promise<void>;
 }

packages/wallet/test/SingleAddressWallet.test.ts

@@ -75,12 +75,12 @@ describe('Wallet', () => {
     test('submitTx', async () => {
       const { body, hash } = await wallet.initializeTx(props);
       const tx = await wallet.signTx(body, hash);
-      const { confirmed } = wallet.submitTx(tx);
+      const { submitted, confirmed } = wallet.submitTx(tx);
       await confirmed;
       expect(provider.submitTx).toBeCalledTimes(1);
       expect(provider.submitTx).toBeCalledWith(tx);
       expect(txTracker.trackTransaction).toBeCalledTimes(1);
-      expect(txTracker.trackTransaction).toBeCalledWith(tx);
+      expect(txTracker.trackTransaction).toBeCalledWith(tx, submitted);
     });
   });
 });