feat: ini txn bundle

Author: shunkakinoki

intent_config.go

@@ -10,50 +10,95 @@ import (
 	v2 "github.com/0xsequence/go-sequence/core/v2"
 )
 
-// createIntentBundle creates a bundle of transactions with the initial nonce 0
-func createIntentBundle(txns []*Transaction) (common.Hash, error) {
+// `CreateIntentBundle` creates a bundle of transactions with the initial nonce 0
+func CreateIntentBundle(txns []*Transaction) (Transaction, error) {
 	bundle := Transaction{
 		DelegateCall:  false,
 		RevertOnError: true,
 		Transactions:  txns,
 		Nonce:         big.NewInt(0),
 	}
 
-	// Compute the digest for the bundle
-	digest, err := bundle.Digest()
-	if err != nil {
-		return common.Hash{}, fmt.Errorf("failed to compute bundle digest: %w", err)
+	return bundle, nil
+}
+
+// CreateIntentSubdigestLeaves iterates over the provided transactions,
+// validates that each transaction meets the following criteria:
+//   - DelegateCall must be false,
+//   - RevertOnError must be true,
+//   - Nonce must be non-nil and equal to 0.
+//
+// For each valid transaction, it computes the digest and creates a new WalletConfigTreeSubdigestLeaf.
+func CreateIntentSubdigestLeaves(txns []*Transaction) ([]*v2.WalletConfigTreeSubdigestLeaf, error) {
+	var leaves []*v2.WalletConfigTreeSubdigestLeaf
+
+	for i, tx := range txns {
+		// Validate the transaction fields:
+		if tx.DelegateCall {
+			return nil, fmt.Errorf("transaction at index %d: DelegateCall must be false", i)
+		}
+		if !tx.RevertOnError {
+			return nil, fmt.Errorf("transaction at index %d: RevertOnError must be true", i)
+		}
+		if tx.Nonce == nil {
+			return nil, fmt.Errorf("transaction at index %d: Nonce is nil", i)
+		}
+		if tx.Nonce.Cmp(big.NewInt(0)) != 0 {
+			return nil, fmt.Errorf("transaction at index %d: Nonce must be 0", i)
+		}
+
+		// Create the intent bundle.
+		bundle, err := CreateIntentBundle(txns)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create intent bundle: %w", err)
+		}
+
+		// Compute digest of the transaction.
+		digest, err := bundle.Digest()
+		if err != nil {
+			return nil, fmt.Errorf("failed to compute digest for transaction at index %d: %w", i, err)
+		}
+
+		// Create a subdigest leaf with the computed digest.
+		leaf := &v2.WalletConfigTreeSubdigestLeaf{
+			Subdigest: core.Subdigest{Hash: digest},
+		}
+		leaves = append(leaves, leaf)
 	}
 
-	return digest, nil
+	return leaves, nil
 }
 
-// `CreateIntentConfiguration` creates a wallet configuration where the intent's transactions are grouped into the initial subdigest
+// CreateIntentConfiguration creates a wallet configuration where the intent's transactions
+// are grouped into the initial subdigest. It uses the subdigest leaves constructed from the txns.
 func CreateIntentConfiguration(mainSigner common.Address, txns []*Transaction) (*v2.WalletConfig, error) {
-	// Create the bundle digest
-	digest, err := createIntentBundle(txns)
+	// Create the subdigest leaves from the transactions.
+	leaves, err := CreateIntentSubdigestLeaves(txns)
 	if err != nil {
 		return nil, err
 	}
 
-	// Create the main signer leaf (with weight 1)
+	// Convert the slice of subdigest leaves into a slice of v2.WalletConfigTree.
+	var treeNodes []v2.WalletConfigTree
+	for _, leaf := range leaves {
+		treeNodes = append(treeNodes, leaf)
+	}
+
+	// Create the main signer leaf (with weight 1).
 	mainSignerLeaf := &v2.WalletConfigTreeAddressLeaf{
 		Weight:  1,
 		Address: mainSigner,
 	}
 
-	// Create a leaf node from the computed subdigest.
-	subdigestLeaf := &v2.WalletConfigTreeSubdigestLeaf{
-		Subdigest: core.Subdigest{Hash: digest},
-	}
-
-	// Construct the new wallet config using the main signer (as the first leaf) and a tree node for the subdigest.
+	// Construct the new wallet config using:
+	//  • the main signer leaf as the left branch, and
+	//  • a nested tree node containing the subdigest leaves as the right branch.
 	config := &v2.WalletConfig{
 		Threshold_:  1,
 		Checkpoint_: 0,
 		Tree: v2.WalletConfigTreeNodes(
 			mainSignerLeaf,
-			v2.WalletConfigTreeNodes(subdigestLeaf),
+			v2.WalletConfigTreeNodes(treeNodes...),
 		),
 	}
 

intent_config_test.go

@@ -15,6 +15,45 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestCreateIntentSubdigestLeaves_Valid(t *testing.T) {
+	// Create a valid transaction (stx) with required fields.
+	stx := &sequence.Transaction{
+		DelegateCall:  false,
+		RevertOnError: true,
+		Nonce:         big.NewInt(0),
+		// other required fields for stx (if any) are assumed to be set.
+	}
+
+	// Use the valid transaction in a slice.
+	txns := []*sequence.Transaction{stx}
+
+	leaves, err := sequence.CreateIntentSubdigestLeaves(txns)
+	require.NoError(t, err)
+	require.Len(t, leaves, 1, "expected one subdigest leaf")
+
+	// Verify that the leaf's digest matches the transaction's digest.
+	digest, err := stx.Digest()
+	require.NoError(t, err)
+	require.Equal(t, digest, leaves[0].Subdigest.Hash, "digests do not match")
+}
+
+func TestCreateIntentConfiguration_Valid(t *testing.T) {
+	// Create a valid transaction.
+	stx := &sequence.Transaction{
+		DelegateCall:  false,
+		RevertOnError: true,
+		Nonce:         big.NewInt(0),
+	}
+	txns := []*sequence.Transaction{stx}
+
+	// Use a valid main signer address.
+	mainSigner := common.HexToAddress("0x1111111111111111111111111111111111111111")
+
+	config, err := sequence.CreateIntentConfiguration(mainSigner, txns)
+	require.NoError(t, err)
+	require.NotNil(t, config)
+}
+
 func TestCreateIntentConfigurationSignature(t *testing.T) {
 	// Create test wallets
 	eoa1, err := ethwallet.NewWalletFromRandomEntropy()
@@ -26,8 +65,10 @@ func TestCreateIntentConfigurationSignature(t *testing.T) {
 	assert.NoError(t, err)
 
 	stx := &sequence.Transaction{
-		To:   callmockContract.Address,
-		Data: calldata,
+		To:            callmockContract.Address,
+		Data:          calldata,
+		RevertOnError: true,
+		Nonce:         big.NewInt(0),
 	}
 
 	t.Run("signature matches subdigest", func(t *testing.T) {
@@ -96,13 +137,17 @@ func TestCreateIntentConfigurationSignature(t *testing.T) {
 		require.NoError(t, err)
 
 		tx1 := &sequence.Transaction{
-			To:   callmockContract.Address,
-			Data: calldata1,
+			To:            callmockContract.Address,
+			Data:          calldata1,
+			RevertOnError: true,
+			Nonce:         big.NewInt(0),
 		}
 
 		tx2 := &sequence.Transaction{
-			To:   callmockContract.Address,
-			Data: calldata2,
+			To:            callmockContract.Address,
+			Data:          calldata2,
+			RevertOnError: true,
+			Nonce:         big.NewInt(0),
 		}
 
 		// Create signatures for both transactions
@@ -128,3 +173,42 @@ func TestCreateIntentConfigurationSignature(t *testing.T) {
 		require.Equal(t, sig1, sig2, "same transactions should produce same signatures")
 	})
 }
+
+func TestCreateIntentConfigurationSignature_MultipleTransactions(t *testing.T) {
+	// Create test wallets
+	eoa1, err := ethwallet.NewWalletFromRandomEntropy()
+	require.NoError(t, err)
+
+	// Create two valid transactions with different Data fields so their digests differ.
+	stx1 := &sequence.Transaction{
+		DelegateCall:  false,
+		RevertOnError: true,
+		Nonce:         big.NewInt(0),
+		Data:          []byte("transaction1"),
+	}
+	stx2 := &sequence.Transaction{
+		DelegateCall:  false,
+		RevertOnError: true,
+		Nonce:         big.NewInt(0),
+		Data:          []byte("transaction2"),
+	}
+	txns := []*sequence.Transaction{stx1, stx2}
+
+	// Create a signature
+	sig, err := sequence.CreateIntentConfigurationSignature(eoa1.Address(), txns)
+	require.NoError(t, err)
+
+	// Convert the full signature into a hex string.
+	sigHex := common.Bytes2Hex(sig)
+
+	// Create the bundle from the transactions
+	bundle, err := sequence.CreateIntentBundle(txns)
+	require.NoError(t, err)
+
+	// Compute the digest of the bundle
+	bundleDigest, err := bundle.Digest()
+	require.NoError(t, err)
+
+	// Expect that the signature (in hex) contains the substrings of both transactions' digests.
+	assert.Contains(t, sigHex, bundleDigest.Hex()[2:], "signature should contain stx1 digest")
+}