DRAFT Example of EVM transaction removing eip7702 delegation

chain/aptos/client_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/cordialsys/crosschain/builder/buildertest"
 	"github.com/cordialsys/crosschain/chain/aptos/tx_input"
 	"github.com/cordialsys/crosschain/client"
-	"github.com/cordialsys/crosschain/client/tx_info"
+	txinfo "github.com/cordialsys/crosschain/client/tx_info"
 	xctypes "github.com/cordialsys/crosschain/client/types"
 	testtypes "github.com/cordialsys/crosschain/testutil"
 	"github.com/stretchr/testify/require"
@@ -179,7 +179,7 @@ func (s *AptosTestSuite) TestSubmitTx() {
 	client, err := NewClient(asset)
 	require.NoError(err)
 
-	submitReq, err := xctypes.SubmitTxReqFromTx(tf)
+	submitReq, err := xctypes.SubmitTxReqFromTx(xc.APTOS, tf)
 	require.NoError(err)
 	err = client.SubmitTx(s.Ctx, submitReq)
 	require.NoError(err)

chain/bitcoin/client/blockchair/blockchair_test.go

@@ -191,7 +191,7 @@ func TestSubmitTx(t *testing.T) {
 	asset := xc.NewChainConfig("BTC").WithUrl(server.URL).WithNet("testnet").WithAuth("env:_BLOCK_CHAIR_KEY").WithProvider(string(bitcoin.Blockchair))
 	client, err := bitcoin.NewClient(asset)
 	require.NoError(err)
-	tx, err := xctypes.SubmitTxReqFromTx(&tx.Tx{
+	tx, err := xctypes.SubmitTxReqFromTx(xc.BTC, &tx.Tx{
 		MsgTx: wire.NewMsgTx(2),
 	})
 	require.NoError(err)

chain/cardano/client/client_test.go

@@ -415,7 +415,7 @@ func TestSubmitTx(t *testing.T) {
 			tx, err := tx.NewTransfer(args, input)
 			require.NoError(t, err)
 
-			req, err := xctypes.SubmitTxReqFromTx(tx)
+			req, err := xctypes.SubmitTxReqFromTx(xc.ADA, tx)
 			require.NoError(t, err)
 			err = client.SubmitTx(context.Background(), req)
 			if vector.err {

chain/cosmos/client/client_test.go

@@ -333,7 +333,7 @@ func TestSubmitTxErr(t *testing.T) {
 
 	client, _ := client.NewClient(xc.NewChainConfig(""))
 	tx := &tx.Tx{ChainCfg: xc.NewChainConfig("").Base()}
-	req, err := xctypes.SubmitTxReqFromTx(tx)
+	req, err := xctypes.SubmitTxReqFromTx(xc.ATOM, tx)
 	require.NoError(t, err)
 	err = client.SubmitTx(context.Background(), req)
 	require.ErrorContains(t, err, "no Host in request URL")

chain/crosschain/client.go

@@ -280,7 +280,11 @@ func (client *Client) FetchLegacyTxInput(ctx context.Context, from xc.Address, t
 
 // SubmitTx submits via a Crosschain endpoint
 func (client *Client) SubmitTx(ctx context.Context, req xctypes.SubmitTxReq) error {
-	res, err := client.legacyApiCall(ctx, "/submit", req)
+	if req.Chain == "" {
+		// chain is required for the endpoint to route the request to the correct chain
+		req.Chain = client.Asset.GetChain().Chain
+	}
+	res, err := client.legacyApiCall(ctx, "/submit", &req)
 	if err != nil {
 		return err
 	}

chain/dusk/client/client_test.go

@@ -189,7 +189,7 @@ func TestSubmitTx(t *testing.T) {
 			client, err := client.NewClient(config)
 			require.NoError(t, err)
 
-			tx, err := xctypes.SubmitTxReqFromTx(vector.tx)
+			tx, err := xctypes.SubmitTxReqFromTx(xc.DUSK, vector.tx)
 			require.NoError(t, err)
 			err = client.SubmitTx(context.Background(), tx)
 			if vector.err != "" {

chain/evm/client/fetch_input.go

@@ -30,11 +30,19 @@ const (
 
 func (client *Client) eip7702GasLimit(destinationCount int) uint64 {
 	native := client.Asset.GetChain()
-	gasLimit := uint64(500_000) + 100_000*uint64(destinationCount)
+	gasLimitDefault := uint64(500_000)
 	if native.Chain == xc.ArbETH {
+		gasLimitDefault = 4_000_000
+	}
+	if client.Asset.GetChain().GasLimitDefault > 0 {
+		gasLimitDefault = uint64(client.Asset.GetChain().GasLimitDefault)
+	}
+	gasLimit := gasLimitDefault + 100_000*uint64(destinationCount)
+	if native.Chain == xc.ArbETH || native.Chain == xc.MON {
 		// arbeth specifically has different gas limit scale
-		gasLimit = 4_000_000 + 250_000*uint64(destinationCount)
+		gasLimit = gasLimitDefault + 250_000*uint64(destinationCount)
 	}
+
 	return gasLimit
 }
 

chain/evm/tx/tx.go

@@ -44,6 +44,7 @@ func NewTx(chain *xc.ChainBaseConfig, args xcbuilder.TransferArgs, input *tx_inp
 			txInner = NewFeePayerTx(*multiArgs, input, chain)
 		} else {
 			txInner = NewSingleTx(args, input, chain)
+			// txInner = NewSingleTxNoDelegation(args, input, chain)
 		}
 	}
 	return &Tx{

chain/evm/tx/tx_fee_payer.go

@@ -34,6 +34,7 @@ var _ evmTx = &SingleTx{}
 const basicSmartAccountAddressRaw = "0x7785a22Facd31dB653bA4928f1D5B81D093f0b2f"
 
 var basicSmartAccountAddress = common.HexToAddress(basicSmartAccountAddressRaw)
+var noSmartAccountAddress = common.HexToAddress("0x0000000000000000000000000000000000000000")
 
 // keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
 var _DOMAIN_TYPEHASH = common.HexToHash("47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218")

chain/evm/tx/tx_single_nodelegation.go

@@ -0,0 +1,131 @@
+package tx
+
+import (
+	"fmt"
+
+	xc "github.com/cordialsys/crosschain"
+	xcbuilder "github.com/cordialsys/crosschain/builder"
+	"github.com/cordialsys/crosschain/chain/evm/tx/authorization"
+	"github.com/cordialsys/crosschain/chain/evm/tx_input"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type SingleTxNodelegation struct {
+	args  xcbuilder.TransferArgs
+	input *tx_input.TxInput
+	chain *xc.ChainBaseConfig
+
+	signature              xc.TxSignature
+	authorizationSignature xc.TxSignature
+}
+
+var _ evmTx = &SingleTxNodelegation{}
+
+func NewSingleTxNoDelegation(args xcbuilder.TransferArgs, input *tx_input.TxInput, chain *xc.ChainBaseConfig) *SingleTxNodelegation {
+	return &SingleTxNodelegation{
+		args,
+		input,
+		chain,
+		xc.TxSignature{},
+		xc.TxSignature{},
+	}
+}
+
+func (tx *SingleTxNodelegation) BuildEthTx() (*types.Transaction, error) {
+	destination, amount, data, err := EvmDestinationAndAmountAndData(tx.args.GetTo(), tx.args.GetAmount(), &tx.args)
+	if err != nil {
+		return nil, err
+	}
+	chainId := GetChainId(tx.chain, tx.input)
+	// ethTx := types.NewTx(&types.DynamicFeeTx{
+	// 	ChainID:   tx.input.ChainId.Int(),
+	// 	Nonce:     tx.input.Nonce,
+	// 	GasTipCap: tx.input.GasTipCap.Int(),
+	// 	GasFeeCap: tx.input.GasFeeCap.Int(),
+	// 	Gas:       tx.input.GasLimit,
+	// 	To:        &destination,
+	// 	Value:     amount,
+	// 	Data:      data,
+	// })
+	// if len(tx.signature) > 0 {
+	// 	ethTx, err = ethTx.WithSignature(GetEthSigner(tx.chain, tx.input), tx.signature)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// }
+	auth := authorization.NewUnsignedAuthorization(chainId, noSmartAccountAddress, tx.input.Nonce+1)
+	// fmt.Println("--- auth address", auth.Address.String())
+	auth.SetSignature(tx.authorizationSignature)
+
+	ethTx := types.NewTx(&types.SetCodeTx{
+		ChainID: &chainId,
+
+		Nonce:     tx.input.Nonce,
+		GasTipCap: uint256FromBig(tx.input.GasTipCap.Int()),
+		GasFeeCap: uint256FromBig(tx.input.GasFeeCap.Int()),
+		Gas:       tx.input.GasLimit,
+		To:        destination,
+		Value:     uint256FromBig(amount),
+		Data:      data,
+		AuthList: []types.SetCodeAuthorization{
+			auth.SetCodeAuthorization(),
+		},
+	})
+	if len(tx.signature) > 0 {
+		ethTx, err = ethTx.WithSignature(GetEthSigner(tx.chain, tx.input), tx.signature)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return ethTx, nil
+}
+
+func (tx *SingleTxNodelegation) Sighashes() ([]*xc.SignatureRequest, error) {
+	// ethTx, err := tx.BuildEthTx()
+	// if err != nil {
+	// 	return nil, err
+	// }
+	// sighash := GetEthSigner(tx.chain, tx.input).Hash(ethTx).Bytes()
+	// return []*xc.SignatureRequest{xc.NewSignatureRequest(sighash)}, nil
+	chainId := GetChainId(tx.chain, tx.input)
+	auth := authorization.NewUnsignedAuthorization(chainId, noSmartAccountAddress, tx.input.Nonce+1)
+	authSighash, err := auth.Sighash()
+	return []*xc.SignatureRequest{
+		xc.NewSignatureRequest(authSighash),
+	}, err
+}
+
+func (tx *SingleTxNodelegation) AdditionalSighashes() ([]*xc.SignatureRequest, error) {
+	if len(tx.authorizationSignature) == 0 {
+		return nil, fmt.Errorf("missing initial signature responses")
+	}
+	if len(tx.signature) > 0 {
+		// done
+		return nil, nil
+	}
+	ethTx, err := tx.BuildEthTx()
+	if err != nil {
+		return nil, err
+	}
+	sighash := GetEthSigner(tx.chain, tx.input).Hash(ethTx).Bytes()
+	return []*xc.SignatureRequest{xc.NewSignatureRequest(sighash)}, nil
+}
+
+func (tx *SingleTxNodelegation) AddSignatures(signatures []*xc.SignatureResponse) {
+	// first signature is the authorization
+	tx.authorizationSignature = signatures[0].Signature
+	if len(signatures) > 1 {
+		tx.signature = signatures[1].Signature
+	}
+	// fmt.Println("--- authorization signature", tx.authorizationSignature)
+	// fmt.Println("--- signature", tx.signature)
+}
+
+func (tx *SingleTxNodelegation) Serialize() ([]byte, error) {
+	ethTx, err := tx.BuildEthTx()
+	if err != nil {
+		return nil, err
+	}
+	return ethTx.MarshalBinary()
+}

chain/evm/tx_input/tx_input.go

@@ -11,7 +11,7 @@ import (
 // TxInput for EVM
 type TxInput struct {
 	xc.TxInputEnvelope
-	Nonce       uint64     `json:"nonce,omitempty"`
+	Nonce       uint64     `json:"nonce"`
 	FromAddress xc.Address `json:"from_address,omitempty"`
 	GasLimit    uint64     `json:"gas_limit,omitempty"`
 	// DynamicFeeTx
@@ -28,7 +28,7 @@ type TxInput struct {
 	ChainId xc.AmountBlockchain `json:"chain_id,omitempty"`
 
 	// For eip7702 transactions
-	BasicSmartAccountNonce uint64     `json:"basic_smart_account_nonce,omitempty"`
+	BasicSmartAccountNonce uint64     `json:"basic_smart_account_nonce"`
 	FeePayerAddress        xc.Address `json:"fee_payer_address,omitempty"`
 	FeePayerNonce          uint64     `json:"fee_payer_nonce,omitempty"`
 

chain/filecoin/client/client_test.go

@@ -290,7 +290,7 @@ func TestSubmitTx(t *testing.T) {
 			defer server.Close()
 
 			client, _ := client.NewClient(xc.NewChainConfig(xc.FIL, xc.DriverFilecoin).WithUrl(server.URL).WithNet("mainnet"))
-			tx, err := xctypes.SubmitTxReqFromTx(v.tx)
+			tx, err := xctypes.SubmitTxReqFromTx(xc.FIL, v.tx)
 			require.NoError(t, err)
 			err = client.SubmitTx(context.Background(), tx)
 			if err != nil {

chain/internet_computer/client/client_test.go

@@ -31,7 +31,7 @@ func TestFetchTxInput(t *testing.T) {
 func TestSubmitTx(t *testing.T) {
 
 	client, _ := client.NewClient(xc.NewChainConfig(""))
-	tx, err := xctypes.SubmitTxReqFromTx(&tx.Tx{})
+	tx, err := xctypes.SubmitTxReqFromTx(xc.ICP, &tx.Tx{})
 	require.EqualError(t, err, "failed to serialize tx: not implemented")
 	err = client.SubmitTx(context.Background(), tx)
 	require.EqualError(t, err, "not implemented")

chain/kaspa/client/client_test.go

@@ -31,7 +31,7 @@ func TestFetchTxInput(t *testing.T) {
 func TestSubmitTx(t *testing.T) {
 
 	client, _ := client.NewClient(xc.NewChainConfig(""))
-	tx, err := xctypes.SubmitTxReqFromTx(&tx.Tx{})
+	tx, err := xctypes.SubmitTxReqFromTx(xc.KAS, &tx.Tx{})
 	require.EqualError(t, err, "failed to serialize tx: not implemented")
 	err = client.SubmitTx(context.Background(), tx)
 	require.EqualError(t, err, "not implemented")

chain/solana/client/client_test.go

@@ -15,7 +15,7 @@ import (
 	"github.com/cordialsys/crosschain/chain/solana/types"
 	xclient "github.com/cordialsys/crosschain/client"
 	"github.com/cordialsys/crosschain/client/errors"
-	"github.com/cordialsys/crosschain/client/tx_info"
+	txinfo "github.com/cordialsys/crosschain/client/tx_info"
 	xctypes "github.com/cordialsys/crosschain/client/types"
 	testtypes "github.com/cordialsys/crosschain/testutil"
 	bin "github.com/gagliardetto/binary"
@@ -370,7 +370,7 @@ func TestSubmitTxSuccess(t *testing.T) {
 	server, close := testtypes.MockJSONRPC(t, fmt.Sprintf("\"%s\"", tx.Hash()))
 	defer close()
 	client, _ := client.NewClient(xc.NewChainConfig(xc.SOL).WithUrl(server.URL))
-	req, err := xctypes.SubmitTxReqFromTx(&testtypes.MockXcTx{
+	req, err := xctypes.SubmitTxReqFromTx(xc.SOL, &testtypes.MockXcTx{
 		SerializedSignedTx: serialized_tx,
 		Signatures:         []xc.TxSignature{{1, 2, 3, 4}},
 	})
@@ -381,7 +381,7 @@ func TestSubmitTxSuccess(t *testing.T) {
 func TestSubmitTxErr(t *testing.T) {
 
 	client, _ := client.NewClient(xc.NewChainConfig(""))
-	tx, err := xctypes.SubmitTxReqFromTx(&tx.Tx{
+	tx, err := xctypes.SubmitTxReqFromTx(xc.SOL, &tx.Tx{
 		SolTx: &solana.Transaction{},
 	})
 	require.NoError(t, err)

chain/sui/client_test.go

@@ -891,7 +891,7 @@ func TestTransfers(t *testing.T) {
 			})
 			require.NoError(err)
 
-			req, err := xctypes.SubmitTxReqFromTx(tx)
+			req, err := xctypes.SubmitTxReqFromTx(xc.SUI, tx)
 			require.NoError(err)
 			err = client.SubmitTx(context.Background(), req)
 			require.NoError(err)

chain/template/client/client_test.go

@@ -31,7 +31,7 @@ func TestFetchTxInput(t *testing.T) {
 func TestSubmitTx(t *testing.T) {
 
 	client, _ := client.NewClient(xc.NewChainConfig(""))
-	tx, err := xctypes.SubmitTxReqFromTx(&tx.Tx{})
+	tx, err := xctypes.SubmitTxReqFromTx("", &tx.Tx{})
 	require.EqualError(t, err, "failed to serialize tx: not implemented")
 	err = client.SubmitTx(context.Background(), tx)
 	require.EqualError(t, err, "not implemented")

chain/xlm/client/client_test.go

@@ -688,7 +688,7 @@ func TestSubmitTx(t *testing.T) {
 				WithChainID("Test SDF Network ; September 2015"),
 			)
 
-			req, err := xctypes.SubmitTxReqFromTx(vector.txInput)
+			req, err := xctypes.SubmitTxReqFromTx(xc.XLM, vector.txInput)
 			if err != nil {
 				require.NotEqual(t, err, "")
 				require.ErrorContains(t, err, vector.error)

chain/xrp/client/client_test.go

@@ -320,7 +320,7 @@ func TestSubmitTx(t *testing.T) {
 
 		client, _ := xrpClient.NewClient(xc.NewChainConfig(xc.XRP).WithUrl(server.URL))
 
-		req, err := xctypes.SubmitTxReqFromTx(vector.txInput)
+		req, err := xctypes.SubmitTxReqFromTx(xc.XRP, vector.txInput)
 		require.NoError(t, err)
 		err = client.SubmitTx(context.Background(), req)
 		require.NoError(t, err)

ci/mult_transfer_test.go

@@ -247,7 +247,7 @@ func TestMultiTransfer(t *testing.T) {
 	}
 
 	// Submit transaction
-	req, err := xctypes.SubmitTxReqFromTx(tx)
+	req, err := xctypes.SubmitTxReqFromTx(chainConfig.Chain, tx)
 	require.NoError(t, err)
 	err = client.SubmitTx(context.Background(), req)
 	require.NoError(t, err)

ci/transfer_test.go

@@ -195,7 +195,7 @@ func TestTransfer(t *testing.T) {
 		}
 	}
 
-	req, err := xctypes.SubmitTxReqFromTx(tx)
+	req, err := xctypes.SubmitTxReqFromTx(chainConfig.Chain, tx)
 	require.NoError(t, err)
 	err = client.SubmitTx(context.Background(), req)
 	require.NoError(t, err)

client/types/api.go

@@ -45,7 +45,7 @@ func (tx *SubmitTxReq) GetMetadata() ([]byte, bool, error) {
 	return []byte(tx.BroadcastInput), tx.BroadcastInput != "", nil
 }
 
-func SubmitTxReqFromTx(tx xc.Tx) (SubmitTxReq, error) {
+func SubmitTxReqFromTx(chain xc.NativeAsset, tx xc.Tx) (SubmitTxReq, error) {
 	metadata := ""
 	if mtx, ok := tx.(xc.TxWithMetadata); ok {
 		md, _, err := mtx.GetMetadata()
@@ -55,14 +55,23 @@ func SubmitTxReqFromTx(tx xc.Tx) (SubmitTxReq, error) {
 		metadata = string(md)
 	}
 
+	legacySigs := [][]byte{}
+	if mtx, ok := tx.(xc.TxLegacyGetSignatures); ok {
+		for _, sig := range mtx.GetSignatures() {
+			legacySigs = append(legacySigs, sig)
+		}
+	}
+
 	txData, err := tx.Serialize()
 	if err != nil {
 		return SubmitTxReq{}, fmt.Errorf("failed to serialize tx: %w", err)
 	}
 
 	return SubmitTxReq{
-		TxData:         txData,
-		BroadcastInput: metadata,
+		Chain:              chain,
+		TxData:             txData,
+		LegacyTxSignatures: legacySigs,
+		BroadcastInput:     metadata,
 	}, nil
 }