TXM In-memory: address_state methods: step 3-03

common/txmgr/address_state.go

@@ -1,6 +1,7 @@
 package txmgr
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
@@ -188,32 +189,124 @@ func (as *AddressState[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) AddTxT
 }
 
 // MoveUnstartedToInProgress moves the next unstarted transaction to the in-progress state.
+// The supplied txAttempt is added to the transaction.
+// It returns an error if there is already a transaction in progress.
+// It returns an error if there is no unstarted transaction to move to in_progress.
 func (as *AddressState[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) MoveUnstartedToInProgress(
-	etx *txmgrtypes.Tx[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE],
-	txAttempt *txmgrtypes.TxAttempt[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE],
+	txID int64, seq SEQ, broadcastAt time.Time, initialBroadcastAt time.Time,
+	txAttempt txmgrtypes.TxAttempt[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE],
 ) error {
+	as.Lock()
+	defer as.Unlock()
+
+	if as.inprogressTx != nil {
+		return fmt.Errorf("move_unstarted_to_in_progress: address %s already has a transaction in progress", as.fromAddress)
+	}
+
+	tx := as.unstartedTxs.RemoveTxByID(txID)
+	if tx == nil {
+		return fmt.Errorf("move_unstarted_to_in_progress: no unstarted transaction to move to in_progress")
+	}
+	tx.State = TxInProgress
+	tx.TxAttempts = []txmgrtypes.TxAttempt[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]{txAttempt}
+	tx.Sequence = &seq
+	tx.BroadcastAt = &broadcastAt
+	tx.InitialBroadcastAt = &initialBroadcastAt
+
+	as.attemptHashToTxAttempt[txAttempt.Hash] = txAttempt
+	as.inprogressTx = tx
+
 	return nil
 }
 
 // MoveConfirmedMissingReceiptToUnconfirmed moves the confirmed missing receipt transaction to the unconfirmed state.
+// It returns an error if there is no confirmed missing receipt transaction with the given ID.
 func (as *AddressState[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) MoveConfirmedMissingReceiptToUnconfirmed(
 	txID int64,
 ) error {
+	as.Lock()
+	defer as.Unlock()
+
+	tx, ok := as.confirmedMissingReceiptTxs[txID]
+	if !ok || tx == nil {
+		return fmt.Errorf("move_confirmed_missing_receipt_to_unconfirmed: no confirmed_missing_receipt transaction with ID %d", txID)
+	}
+
+	tx.State = TxUnconfirmed
+	as.unconfirmedTxs[tx.ID] = tx
+	delete(as.confirmedMissingReceiptTxs, tx.ID)
+
 	return nil
 }
 
 // MoveInProgressToUnconfirmed moves the in-progress transaction to the unconfirmed state.
+// It returns an error if there is no transaction in progress.
+// It returns an error if the transaction in progress does not have an attempt with the given ID.
 func (as *AddressState[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) MoveInProgressToUnconfirmed(
-	etx txmgrtypes.Tx[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE],
-	txAttempt txmgrtypes.TxAttempt[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE],
+	txError null.String, broadcastAt time.Time, initialBroadcastAt time.Time,
+	txAttemptID int64,
 ) error {
+	as.Lock()
+	defer as.Unlock()
+
+	tx := as.inprogressTx
+	if tx == nil {
+		return fmt.Errorf("move_in_progress_to_unconfirmed: no transaction in progress")
+	}
+
+	tx.State = TxUnconfirmed
+	tx.Error = txError
+	tx.BroadcastAt = &broadcastAt
+	tx.InitialBroadcastAt = &initialBroadcastAt
+
+	found := false
+	for i := 0; i < len(tx.TxAttempts); i++ {
+		txAttempt := tx.TxAttempts[i]
+		if txAttempt.ID == txAttemptID {
+			txAttempt.State = txmgrtypes.TxAttemptBroadcast
+			tx.TxAttempts[i] = txAttempt
+			found = true
+			break
+		}
+	}
+	if !found {
+		return fmt.Errorf("move_in_progress_to_unconfirmed: transaction in progress does not have an attempt with ID %d", txAttemptID)
+	}
+
+	as.unconfirmedTxs[tx.ID] = tx
+	as.inprogressTx = nil
+
 	return nil
 }
 
 // MoveUnconfirmedToConfirmed moves the unconfirmed transaction to the confirmed state.
+// It returns an error if there is no unconfirmed transaction with the given ID.
+// It returns an error if there is no attempt with the given receipt.
 func (as *AddressState[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) MoveUnconfirmedToConfirmed(
 	receipt txmgrtypes.ChainReceipt[TX_HASH, BLOCK_HASH],
 ) error {
+	as.Lock()
+	defer as.Unlock()
+
+	txAttempt, ok := as.attemptHashToTxAttempt[receipt.GetTxHash()]
+	if !ok {
+		return fmt.Errorf("move_unconfirmed_to_confirmed: no unconfirmed transaction with receipt %v", receipt)
+	}
+	// TODO(jtw): not sure how to set blocknumber, transactionindex, and receipt on conflict
+	txAttempt.Receipts = []txmgrtypes.ChainReceipt[TX_HASH, BLOCK_HASH]{receipt}
+	txAttempt.State = txmgrtypes.TxAttemptBroadcast
+	if txAttempt.BroadcastBeforeBlockNum == nil {
+		blockNum := receipt.GetBlockNumber().Int64()
+		txAttempt.BroadcastBeforeBlockNum = &blockNum
+	}
+	tx, ok := as.unconfirmedTxs[txAttempt.TxID]
+	if !ok {
+		// TODO: WHAT SHOULD WE DO HERE?
+		// THIS WOULD BE A BIG BUG
+		return fmt.Errorf("move_unconfirmed_to_confirmed: no unconfirmed transaction with ID %d", txAttempt.TxID)
+	}
+	tx.State = TxConfirmed
+
 	return nil
 }