Preserve timed refund preimage (#352)

Author: Agusx1211

intent_config_test.go

@@ -359,6 +359,11 @@ func TestCreateIntentConfigurationWithTimedRefundSapient(t *testing.T) {
 	sapientLeaf := findSapientSignerLeaf(config.Tree, timedRefundSigner)
 	require.NotNil(t, sapientLeaf)
 	require.Equal(t, expectedSapientImageHash, sapientLeaf.ImageHash_.Hash)
+	preimage, ok := sapientLeaf.ImageHash_.Preimage.(*sequence.TimedRefundSapientImageHashPreimage)
+	require.True(t, ok)
+	require.Equal(t, destination, preimage.Destination)
+	require.Equal(t, uint64(1_750_000_000), preimage.UnlockTimestamp)
+	require.Equal(t, expectedSapientImageHash, preimage.ImageHash().Hash)
 
 	plainConfig, err := sequence.CreateIntentConfiguration(mainSigner, []*v3.CallsPayload{&payload}, 0, nil)
 	require.NoError(t, err)
@@ -406,6 +411,20 @@ func TestCreateIntentConfigurationWithTimedRefundSapient_ZeroWeight(t *testing.T
 	require.EqualError(t, err, "timed refund sapient signer weight is zero")
 }
 
+func TestTimedRefundSapientImageHash(t *testing.T) {
+	destination := common.HexToAddress("0x4444444444444444444444444444444444444444")
+
+	imageHash, err := sequence.TimedRefundSapientImageHash(destination, 1_750_000_000)
+	require.NoError(t, err)
+	require.Equal(t, common.HexToHash("0x577e11f2280512fff4541fc08cc7eb98357bdcff482db5634db7327e3c97ba58"), imageHash.Hash)
+
+	preimage, ok := imageHash.Preimage.(*sequence.TimedRefundSapientImageHashPreimage)
+	require.True(t, ok)
+	require.Equal(t, destination, preimage.Destination)
+	require.Equal(t, uint64(1_750_000_000), preimage.UnlockTimestamp)
+	require.Equal(t, imageHash.Hash, preimage.ImageHash().Hash)
+}
+
 func TestGetIntentConfigurationSignature(t *testing.T) {
 	// Create test wallets
 	eoa1, err := ethwallet.NewWalletFromRandomEntropy()

intent_config_timed_refund.go

@@ -22,6 +22,26 @@ type TimedRefundIntentConfigurationSigner struct {
 	Weight          uint8
 }
 
+// TimedRefundSapientImageHashPreimage is the typed preimage for a timed-refund sapient signer.
+// It preserves the refund destination and unlock timestamp alongside the irreversible hash.
+type TimedRefundSapientImageHashPreimage struct {
+	Destination     common.Address
+	UnlockTimestamp uint64
+}
+
+func (p *TimedRefundSapientImageHashPreimage) ImageHash() core.ImageHash {
+	if p == nil {
+		return core.ImageHash{}
+	}
+
+	imageHash, err := TimedRefundSapientImageHash(p.Destination, p.UnlockTimestamp)
+	if err != nil {
+		panic(fmt.Errorf("timed refund sapient image hash preimage: %w", err))
+	}
+
+	return imageHash
+}
+
 // CreateIntentConfigurationWithTimedRefundSapient creates an intent configuration that includes
 // a timed-refund sapient signer leaf in addition to the default any-address subdigests.
 func CreateIntentConfigurationWithTimedRefundSapient(
@@ -51,7 +71,7 @@ func createTimedRefundSapientSignerLeaf(signer TimedRefundIntentConfigurationSig
 		return nil, fmt.Errorf("timed refund sapient signer weight is zero")
 	}
 
-	imageHash, err := timedRefundSapientImageHash(signer.Destination, signer.UnlockTimestamp)
+	imageHash, err := TimedRefundSapientImageHash(signer.Destination, signer.UnlockTimestamp)
 	if err != nil {
 		return nil, err
 	}
@@ -86,7 +106,9 @@ func mustTimedRefundSapientImageHashArguments() abi.Arguments {
 	}
 }
 
-func timedRefundSapientImageHash(destination common.Address, unlockTimestamp uint64) (core.ImageHash, error) {
+// TimedRefundSapientImageHash computes the image hash for a timed-refund sapient signer and
+// includes the recoverable typed preimage in the returned core.ImageHash.
+func TimedRefundSapientImageHash(destination common.Address, unlockTimestamp uint64) (core.ImageHash, error) {
 	encoded, err := timedRefundSapientImageHashArguments.Pack(
 		"timed-refund",
 		destination,
@@ -96,5 +118,13 @@ func timedRefundSapientImageHash(destination common.Address, unlockTimestamp uin
 		return core.ImageHash{}, fmt.Errorf("failed to ABI pack timed refund sapient image hash: %w", err)
 	}
 
-	return core.ImageHash{Hash: crypto.Keccak256Hash(encoded)}, nil
+	preimage := &TimedRefundSapientImageHashPreimage{
+		Destination:     destination,
+		UnlockTimestamp: unlockTimestamp,
+	}
+
+	return core.ImageHash{
+		Hash:     crypto.Keccak256Hash(encoded),
+		Preimage: preimage,
+	}, nil
 }