diff --git a/adapters.go b/adapters.go
index b715a684..a2c770cc 100644
--- a/adapters.go
+++ b/adapters.go
@@ -13,61 +13,21 @@ import (
 	rolluptypes "github.com/polymerdao/monomer/x/rollup/types"
 )
 
-var errL1AttributesNotFound = errors.New("L1 attributes tx not found")
-
 // AdaptPayloadTxsToCosmosTxs assumes the deposit transactions come first.
 func AdaptPayloadTxsToCosmosTxs(ethTxs []hexutil.Bytes) (bfttypes.Txs, error) {
+	// L1 Attributes transaction.
 	if len(ethTxs) == 0 {
-		return bfttypes.Txs{}, nil
-	}
-
-	numDepositTxs, err := countDepositTransactions(ethTxs)
-	if err != nil {
-		return nil, fmt.Errorf("count deposit transactions: %v", err)
-	}
-
-	depositTx, err := packDepositTxsToCosmosTx(ethTxs[:numDepositTxs], "")
-	if err != nil {
-		return nil, fmt.Errorf("pack deposit txs: %v", err)
-	}
-	depositTxBytes, err := depositTx.Marshal()
-	if err != nil {
-		return nil, fmt.Errorf("marshal tx: %v", err)
-	}
-
-	cosmosNonDepositTxs, err := convertToCosmosNonDepositTxs(ethTxs[numDepositTxs:])
-	if err != nil {
-		return nil, fmt.Errorf("convert to cosmos txs: %v", err)
+		return nil, errors.New("l1 attributes transaction not found")
 	}
-
-	return append(bfttypes.Txs{depositTxBytes}, cosmosNonDepositTxs...), nil
-}
-
-func countDepositTransactions(ethTxs []hexutil.Bytes) (int, error) {
-	var numDepositTxs int
-	for _, txBytes := range ethTxs {
-		var tx ethtypes.Transaction
-		if err := tx.UnmarshalBinary(txBytes); err != nil {
-			return 0, fmt.Errorf("unmarshal binary: %v", err)
-		}
-		if tx.IsDepositTx() {
-			numDepositTxs++
-		} else {
-			break // Assume deposit transactions must come first.
-		}
-	}
-	if numDepositTxs == 0 {
-		return 0, errL1AttributesNotFound
-	}
-
-	return numDepositTxs, nil
-}
-
-func packDepositTxsToCosmosTx(ethDepositTxs []hexutil.Bytes, _ string) (*rolluptypes.DepositsTx, error) {
+	l1AttributesTxBytes := ethTxs[0]
+	ethTxs = ethTxs[1:]
 	var ethL1AttributesTx ethtypes.Transaction
-	if err := ethL1AttributesTx.UnmarshalBinary(ethDepositTxs[0]); err != nil {
+	if err := ethL1AttributesTx.UnmarshalBinary(l1AttributesTxBytes); err != nil {
 		return nil, fmt.Errorf("unmarshal binary: %v", err)
 	}
+	if ethL1AttributesTx.Type() != ethtypes.DepositTxType {
+		return nil, errors.New("first transaction is not a deposit transaction")
+	}
 	l1BlockInfo, err := derive.L1BlockInfoFromBytes(&rollup.Config{}, uint64(time.Now().Unix()), ethL1AttributesTx.Data())
 	if err != nil {
 		return nil, fmt.Errorf("l1 block info from bytes: %v", err)
@@ -84,37 +44,51 @@ func packDepositTxsToCosmosTx(ethDepositTxs []hexutil.Bytes, _ string) (*rollupt
 			BaseFeeScalar:     l1BlockInfo.BaseFeeScalar,
 			BlobBaseFeeScalar: l1BlockInfo.BlobBaseFeeScalar,
 		},
-		EthTx: ethDepositTxs[0],
+		EthTx: l1AttributesTxBytes,
 	}
-	if l1Attributes.L1BlockInfo.BaseFee != nil {
+	if l1BlockInfo.BaseFee != nil {
 		l1Attributes.L1BlockInfo.BaseFee = l1BlockInfo.BaseFee.Bytes()
 	}
-	if l1Attributes.L1BlockInfo.BlobBaseFee != nil {
+	if l1BlockInfo.BlobBaseFee != nil {
 		l1Attributes.L1BlockInfo.BlobBaseFee = l1BlockInfo.BlobBaseFee.Bytes()
 	}
 
+	// User deposit transactions.
 	depositTxs := make([]*rolluptypes.MsgApplyUserDeposit, 0)
-	if len(ethDepositTxs) > 1 {
-		for _, ethDepositTx := range ethDepositTxs[1:] {
-			depositTxs = append(depositTxs, &rolluptypes.MsgApplyUserDeposit{
-				Tx: ethDepositTx,
-			})
+	for _, ethDepositTxBytes := range ethTxs {
+		var ethDepositTx ethtypes.Transaction
+		if err := ethDepositTx.UnmarshalBinary(ethDepositTxBytes); err != nil {
+			return nil, fmt.Errorf("unmarshal binary eth deposit tx bytes: %v", err)
+		}
+		if !ethDepositTx.IsDepositTx() {
+			break // We have reached the end of the deposit txs.
 		}
+		depositTxs = append(depositTxs, &rolluptypes.MsgApplyUserDeposit{
+			Tx: ethDepositTxBytes,
+		})
 	}
-	return &rolluptypes.DepositsTx{
+	ethTxs = ethTxs[len(depositTxs):]
+
+	cosmosTxs := make(bfttypes.Txs, 0, 1+len(ethTxs))
+
+	depositTxBytes, err := (&rolluptypes.DepositsTx{
 		L1Attributes: l1Attributes,
 		UserDeposits: depositTxs,
-	}, nil
-}
+	}).Marshal()
+	if err != nil {
+		return nil, fmt.Errorf("marshal tx: %v", err)
+	}
+	cosmosTxs = append(cosmosTxs, depositTxBytes)
 
-func convertToCosmosNonDepositTxs(nonDepositTxs []hexutil.Bytes) (bfttypes.Txs, error) {
-	// Unpack Cosmos txs from ethTxs.
-	cosmosTxs := make(bfttypes.Txs, 0, len(nonDepositTxs))
-	for _, cosmosTx := range nonDepositTxs {
+	// Non-deposit transactions.
+	for _, cosmosTx := range ethTxs {
 		var tx ethtypes.Transaction
 		if err := tx.UnmarshalBinary(cosmosTx); err != nil {
 			return nil, fmt.Errorf("unmarshal binary tx: %v", err)
 		}
+		if tx.IsDepositTx() {
+			return nil, errors.New("found a deposit tx after a non-deposit tx")
+		}
 		cosmosTxs = append(cosmosTxs, tx.Data())
 	}
 
@@ -126,42 +100,41 @@ func AdaptCosmosTxsToEthTxs(cosmosTxs bfttypes.Txs) (ethtypes.Transactions, erro
 		return ethtypes.Transactions{}, nil
 	}
 	txsBytes := cosmosTxs.ToSliceOfBytes()
-	ethTxs, err := GetDepositTxs(txsBytes[0])
-	if err != nil {
-		return nil, fmt.Errorf("get deposit txs: %v", err)
-	}
-	if len(txsBytes) > 1 {
-		for _, txBytes := range txsBytes[1:] {
-			ethTxs = append(ethTxs, AdaptNonDepositCosmosTxToEthTx(txBytes))
-		}
-	}
-
-	return ethTxs, nil
-}
+	cosmosDepositTxBytes := txsBytes[0]
+	txsBytes = txsBytes[1:]
 
-func GetDepositTxs(cosmosDepositTx []byte) (ethtypes.Transactions, error) {
-	msg := new(rolluptypes.DepositsTx)
-	if err := msg.Unmarshal(cosmosDepositTx); err != nil {
+	cosmosDepositTx := new(rolluptypes.DepositsTx)
+	if err := cosmosDepositTx.Unmarshal(cosmosDepositTxBytes); err != nil {
 		return nil, fmt.Errorf("unmarshal MsgL1Txs msg: %v", err)
 	}
+
+	// L1 Attributes.
 	var ethL1AttributesTx ethtypes.Transaction
-	if err := ethL1AttributesTx.UnmarshalBinary(msg.L1Attributes.EthTx); err != nil {
+	if err := ethL1AttributesTx.UnmarshalBinary(cosmosDepositTx.L1Attributes.EthTx); err != nil {
 		return nil, fmt.Errorf("unmarshal binary l1 attributes tx: %v", err)
 	}
-	txs := ethtypes.Transactions{&ethL1AttributesTx}
 
-	ethTxsBytes := msg.GetUserDeposits()
-	for _, userDepositTx := range ethTxsBytes {
-		var tx ethtypes.Transaction
-		if err := tx.UnmarshalBinary(userDepositTx.Tx); err != nil {
+	ethTxs := ethtypes.Transactions{&ethL1AttributesTx}
+
+	// User Deposits.
+	cosmosUserDepositTxs := cosmosDepositTx.GetUserDeposits()
+	for _, cosmosUserDepositTx := range cosmosUserDepositTxs {
+		var ethUserDepositTx ethtypes.Transaction
+		if err := ethUserDepositTx.UnmarshalBinary(cosmosUserDepositTx.Tx); err != nil {
 			return nil, fmt.Errorf("unmarshal binary user deposit tx: %v", err)
 		}
-		if !tx.IsDepositTx() {
-			return nil, errors.New("MsgL1Tx contains non-deposit tx")
+		if !ethUserDepositTx.IsDepositTx() {
+			return nil, errors.New("cosmos deposit tx contains non-deposit tx")
 		}
-		txs = append(txs, &tx)
+		ethTxs = append(ethTxs, &ethUserDepositTx)
+	}
+
+	// Non-deposit transactions.
+	for _, txBytes := range txsBytes {
+		ethTxs = append(ethTxs, AdaptNonDepositCosmosTxToEthTx(txBytes))
 	}
-	return txs, nil
+
+	return ethTxs, nil
 }
 
 func AdaptNonDepositCosmosTxToEthTx(cosmosTx bfttypes.Tx) *ethtypes.Transaction {