solana: refactor conflict checking and introduce SetPayload for call inputs

Author: conorpp

chain/evm/call/call.go

@@ -144,3 +144,7 @@ func (tx *TxCall) Serialize() ([]byte, error) {
 	}
 	return ethTx.MarshalBinary()
 }
+
+func (tx *TxCall) GetPayload() (xc.TxCallPayload, bool) {
+	return nil, false
+}

chain/solana/call/call.go

@@ -132,7 +132,7 @@ func (c *TxCall) IsRetryable() (bool, string) {
 }
 
 func (c *TxCall) SetInput(input xc.CallTxInput) error {
-	txInput := input.(*tx_input.CallInput)
+	txInput := input.(tx_input.GetTxInfo)
 
 	if ok, _ := c.IsRetryable(); !ok {
 		// we cannot modify the transaction in any way as it has an external signer.
@@ -141,18 +141,11 @@ func (c *TxCall) SetInput(input xc.CallTxInput) error {
 
 	// If the nonce account is used, do not use recent-blockhash, as this
 	// transaction is very likely using durable-nonce.
-	usingDurableNonce := false
-	for _, accountKey := range c.SolTx.Message.AccountKeys {
-		if !txInput.DurableNonceAccount.IsZero() && txInput.DurableNonceAccount.Equals(accountKey) {
-			usingDurableNonce = true
-			break
-		}
-
-	}
+	usingDurableNonce := txInput.DoesTxUseDurableNonce(c.SolTx)
 	if !usingDurableNonce {
 		// Update using the latest blockhash to prevent unwanted expiry.
 		// Otherwise it's bad experience if transaction was waiting for approval only to immediately expire after.
-		c.SolTx.Message.RecentBlockhash = txInput.RecentBlockHash
+		c.SolTx.Message.RecentBlockhash = txInput.GetRecentBlockhash()
 	}
 
 	return nil
@@ -220,3 +213,7 @@ func (c *TxCall) SetSignatures(signatures ...*xc.SignatureResponse) error {
 func (c *TxCall) Serialize() ([]byte, error) {
 	return c.SolTx.MarshalBinary()
 }
+
+func (c *TxCall) GetPayload() (xc.TxCallPayload, bool) {
+	return tx_input.NewCallPayload(c.SolTx), true
+}

chain/solana/tx_input/call.go

@@ -1,8 +1,11 @@
 package tx_input
 
 import (
+	"fmt"
+
 	xc "github.com/cordialsys/crosschain"
 	"github.com/cordialsys/crosschain/factory/drivers/registry"
+	"github.com/gagliardetto/solana-go"
 )
 
 func init() {
@@ -13,6 +16,8 @@ type CallInput struct {
 	TxInput
 }
 
+var _ xc.TxInput = &CallInput{}
+var _ xc.TxInputWithCall = &CallInput{}
 var _ xc.TxVariantInput = &CallInput{}
 var _ xc.CallTxInput = &CallInput{}
 
@@ -21,3 +26,32 @@ func (*CallInput) Calling() {}
 func (*CallInput) GetVariant() xc.TxVariantInputType {
 	return xc.NewCallingInputType(xc.DriverSolana)
 }
+
+func NewCallPayload(solTx *solana.Transaction) *CallPayload {
+	return &CallPayload{solTx}
+}
+
+type CallPayload struct {
+	solTx *solana.Transaction
+}
+
+var _ xc.TxCallPayload = &CallPayload{}
+
+func (p *CallPayload) IsTxCallPayload() {}
+
+func (input *CallInput) SetCall(call xc.TxCallPayload) error {
+	txCall, ok := call.(*CallPayload)
+	if !ok {
+		return fmt.Errorf("invalid call payload for solana: %T", call)
+	}
+
+	solanaTx := txCall.solTx
+	input.TxInput.RecentBlockHash = solanaTx.Message.RecentBlockhash
+	if input.DoesTxUseDurableNonce(solanaTx) {
+		input.TxInput.DurableNonce = solanaTx.Message.RecentBlockhash
+	} else {
+		input.TxInput.DurableNonceAccount = solana.PublicKey{}
+		input.TxInput.DurableNonce = solana.Hash{}
+	}
+	return nil
+}

chain/solana/tx_input/tx_input.go

@@ -37,14 +37,13 @@ type TxInput struct {
 type GetTxInfo interface {
 	GetTimestamp() int64
 	GetRecentBlockhash() solana.Hash
-}
 
-// GetDurableNonceInfo is an interface to retrieve durable nonce information from a TxInput.
-type GetDurableNonceInfo interface {
 	GetDurableNonceAccount() solana.PublicKey
 	GetDurableNonceValue() solana.Hash
 	HasDurableNonce() bool
 	IsCreatingDurableNonceAccount() bool
+
+	DoesTxUseDurableNonce(tx *solana.Transaction) bool
 }
 
 type TokenAccount struct {
@@ -54,7 +53,6 @@ type TokenAccount struct {
 
 var _ xc.TxInput = &TxInput{}
 var _ GetTxInfo = &TxInput{}
-var _ GetDurableNonceInfo = &TxInput{}
 var _ xc.TxInputWithUnix = &TxInput{}
 
 func init() {
@@ -90,6 +88,25 @@ func (input *TxInput) IsCreatingDurableNonceAccount() bool {
 	return input.ShouldCreateDurableNonce && !input.DurableNonceAccount.IsZero()
 }
 
+func (input *TxInput) DoesTxUseDurableNonce(tx *solana.Transaction) bool {
+	if !input.HasDurableNonce() {
+		return false
+	}
+
+	if tx.Message.RecentBlockhash.Equals(input.DurableNonce) {
+		return true
+	}
+	usingDurableNonce := false
+	for _, accountKey := range tx.Message.AccountKeys {
+		if input.DurableNonceAccount.Equals(accountKey) {
+			usingDurableNonce = true
+			break
+		}
+	}
+
+	return usingDurableNonce
+}
+
 // GetBlockhashForTx returns the blockhash to use for the transaction.
 // If a durable nonce is set and initialized, the nonce value is used instead of a recent blockhash.
 // When the nonce account needs to be created first, the recent blockhash is used.
@@ -155,50 +172,71 @@ func (input *TxInput) IsFeeLimitAccurate() bool {
 	return true
 }
 
+func (input *TxInput) MatchDurableNonce(otherNonce GetTxInfo) (accountMatch, nonceMatch bool) {
+	sameAccount := input.DurableNonceAccount.Equals(otherNonce.GetDurableNonceAccount())
+	if sameAccount {
+		// Both creating the same nonce account = conflict
+		if input.IsCreatingDurableNonceAccount() && otherNonce.IsCreatingDurableNonceAccount() {
+			return true, true
+		}
+		// Both using the same nonce value = conflict (only one can succeed)
+		// Different nonce values = independent (each uses its own nonce)
+		if input.HasDurableNonce() && otherNonce.HasDurableNonce() {
+			return true, input.DurableNonce.Equals(otherNonce.GetDurableNonceValue())
+		}
+	}
+	// different accounts = independent
+	return false, false
+}
+
+func (input *TxInput) DidTimeoutOccur(other GetTxInfo) (timeout bool) {
+	diff := input.Timestamp - other.GetTimestamp()
+	if diff < int64(SafetyTimeoutMargin.Seconds()) || other.GetRecentBlockhash().Equals(input.GetRecentBlockhash()) {
+		return false
+	}
+	return true
+}
+
 func (input *TxInput) IndependentOf(other xc.TxInput) (independent bool) {
-	if otherNonce, ok := other.(GetDurableNonceInfo); ok {
-		sameAccount := !input.DurableNonceAccount.IsZero() &&
-			input.DurableNonceAccount.Equals(otherNonce.GetDurableNonceAccount())
-		if sameAccount {
-			// Both creating the same nonce account = conflict
-			if input.IsCreatingDurableNonceAccount() && otherNonce.IsCreatingDurableNonceAccount() {
-				return false
-			}
-			// Both using the same nonce value = conflict (only one can succeed)
-			// Different nonce values = independent (each uses its own nonce)
-			if input.HasDurableNonce() && otherNonce.HasDurableNonce() {
-				return !input.DurableNonce.Equals(otherNonce.GetDurableNonceValue())
-			}
+	if otherNonce, ok := other.(GetTxInfo); ok {
+		// if input.HasDurableNonce() {
+		_, sameNonce := input.MatchDurableNonce(otherNonce)
+		if sameNonce {
+			// one of the transactions will fail
+			return false
+		} else {
+			// both work
+			return true
 		}
 	}
+	// solana transactions are always independent if no durable nonce
 	return true
 }
 
 func (input *TxInput) SafeFromDoubleSend(other xc.TxInput) (safe bool) {
-	if otherNonce, ok := other.(GetDurableNonceInfo); ok {
-		sameAccount := !input.DurableNonceAccount.IsZero() &&
-			input.DurableNonceAccount.Equals(otherNonce.GetDurableNonceAccount())
+	otherInput, ok := other.(GetTxInfo)
+	if !ok {
+		return false
+	}
+
+	if input.HasDurableNonce() {
+		sameAccount, sameNonce := input.MatchDurableNonce(otherInput)
 		if sameAccount {
-			// Safe only when both have actual nonce values and they match
-			// (the nonce can only be consumed once, so only one tx can land).
-			// If either is missing a nonce (e.g. setup phase), not safe.
-			if input.HasDurableNonce() && otherNonce.HasDurableNonce() {
-				return input.DurableNonce.Equals(otherNonce.GetDurableNonceValue())
+			if sameNonce {
+				// safe
+				return true
+			} else {
+				return false
 			}
-			return false
 		}
 	}
 
 	// For recent blockhash (non-durable-nonce) transactions
-	oldInput, ok := other.(GetTxInfo)
-	if !ok {
-		return false
+	if input.DidTimeoutOccur(otherInput) {
+		return true
 	}
-	diff := input.Timestamp - oldInput.GetTimestamp()
-	if diff < int64(SafetyTimeoutMargin.Seconds()) || oldInput.GetRecentBlockhash().Equals(input.GetRecentBlockhash()) {
-		return false
-	}
-	return true
+
+	return false
 }
 
 func (input *TxInput) SetUnix(unix int64) {

chain/solana/tx_input/tx_input_test.go

@@ -183,22 +183,24 @@ func TestTxInputConflicts(t *testing.T) {
 		},
 	}
 	for i, v := range vectors {
-		newBz, _ := json.Marshal(v.newInput)
-		oldBz, _ := json.Marshal(v.oldInput)
-		fmt.Printf("testcase %d - expect safe=%t, independent=%t\n     newInput = %s\n     oldInput = %s\n", i, v.doubleSpendSafe, v.independent, string(newBz), string(oldBz))
-		fmt.Println()
-		require.Equal(
-			t,
-			v.newInput.IndependentOf(v.oldInput),
-			v.independent,
-			"IndependentOf",
-		)
-		require.Equal(
-			t,
-			v.newInput.SafeFromDoubleSend(v.oldInput),
-			v.doubleSpendSafe,
-			"SafeFromDoubleSend",
-		)
+		t.Run(fmt.Sprintf("case_%d", i), func(t *testing.T) {
+			newBz, _ := json.Marshal(v.newInput)
+			oldBz, _ := json.Marshal(v.oldInput)
+			fmt.Printf("testcase %d - expect safe=%t, independent=%t\n     newInput = %s\n     oldInput = %s\n", i, v.doubleSpendSafe, v.independent, string(newBz), string(oldBz))
+			fmt.Println()
+			require.Equal(
+				t,
+				v.newInput.IndependentOf(v.oldInput),
+				v.independent,
+				"IndependentOf",
+			)
+			require.Equal(
+				t,
+				v.newInput.SafeFromDoubleSend(v.oldInput),
+				v.doubleSpendSafe,
+				"SafeFromDoubleSend",
+			)
+		})
 	}
 }
 

tx.go

@@ -20,6 +20,12 @@ type TxInputWithUnix interface {
 	SetUnix(int64)
 }
 
+// For transactions that come with their own payload, like Calls.
+// This may change how conflict resolution works, like on Solana.
+type TxInputWithCall interface {
+	SetCall(call TxCallPayload) error
+}
+
 type TxInputGasFeeMultiplier interface {
 	SetGasFeePriority(priority GasFeePriority) error
 }
@@ -215,4 +221,11 @@ type TxCall interface {
 	// Indicate if it's possible & safe to retry the call transaction.
 	// Meaning, can we re-sign the transaction with the a new input?
 	IsRetryable() (ok bool, reason string)
+
+	// Used if the tx-input needs to be updated retro-actively, like on Solana.
+	GetPayload() (TxCallPayload, bool)
+}
+
+type TxCallPayload interface {
+	IsTxCallPayload()
 }