diff --git a/chain/aptos/client_test.go b/chain/aptos/client_test.go index 964c4b27..370f32d0 100644 --- a/chain/aptos/client_test.go +++ b/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) diff --git a/chain/bitcoin/client/blockchair/blockchair_test.go b/chain/bitcoin/client/blockchair/blockchair_test.go index 930a9376..f7891e81 100644 --- a/chain/bitcoin/client/blockchair/blockchair_test.go +++ b/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) diff --git a/chain/cardano/client/client_test.go b/chain/cardano/client/client_test.go index 15ab0226..18c2d76e 100644 --- a/chain/cardano/client/client_test.go +++ b/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 { diff --git a/chain/cosmos/client/client_test.go b/chain/cosmos/client/client_test.go index e3f36106..225ff77a 100644 --- a/chain/cosmos/client/client_test.go +++ b/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") diff --git a/chain/crosschain/client.go b/chain/crosschain/client.go index 4c8a5d42..92e856ae 100644 --- a/chain/crosschain/client.go +++ b/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 } diff --git a/chain/dusk/client/client_test.go b/chain/dusk/client/client_test.go index 15abb0f7..a834f6ec 100644 --- a/chain/dusk/client/client_test.go +++ b/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 != "" { diff --git a/chain/evm/client/fetch_input.go b/chain/evm/client/fetch_input.go index bda3b791..54747619 100644 --- a/chain/evm/client/fetch_input.go +++ b/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 } diff --git a/chain/evm/tx/tx.go b/chain/evm/tx/tx.go index 2d171f27..745abbec 100644 --- a/chain/evm/tx/tx.go +++ b/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{ diff --git a/chain/evm/tx/tx_fee_payer.go b/chain/evm/tx/tx_fee_payer.go index 38b68121..856ec653 100644 --- a/chain/evm/tx/tx_fee_payer.go +++ b/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") diff --git a/chain/evm/tx/tx_single_nodelegation.go b/chain/evm/tx/tx_single_nodelegation.go new file mode 100644 index 00000000..7adba886 --- /dev/null +++ b/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() +} diff --git a/chain/evm/tx_input/tx_input.go b/chain/evm/tx_input/tx_input.go index 0d3deea5..1fe5d6ce 100644 --- a/chain/evm/tx_input/tx_input.go +++ b/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"` diff --git a/chain/filecoin/client/client_test.go b/chain/filecoin/client/client_test.go index 18919ed7..399d4c69 100644 --- a/chain/filecoin/client/client_test.go +++ b/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 { diff --git a/chain/internet_computer/client/client_test.go b/chain/internet_computer/client/client_test.go index 23de873c..d8044079 100644 --- a/chain/internet_computer/client/client_test.go +++ b/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") diff --git a/chain/kaspa/client/client_test.go b/chain/kaspa/client/client_test.go index 23de873c..ffcf6e5e 100644 --- a/chain/kaspa/client/client_test.go +++ b/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") diff --git a/chain/solana/client/client_test.go b/chain/solana/client/client_test.go index 9b266467..3045332d 100644 --- a/chain/solana/client/client_test.go +++ b/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) diff --git a/chain/sui/client_test.go b/chain/sui/client_test.go index a4d02740..4605bed4 100644 --- a/chain/sui/client_test.go +++ b/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) diff --git a/chain/template/client/client_test.go b/chain/template/client/client_test.go index 23de873c..695d5932 100644 --- a/chain/template/client/client_test.go +++ b/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") diff --git a/chain/xlm/client/client_test.go b/chain/xlm/client/client_test.go index 2ac154f7..4a3b55fc 100644 --- a/chain/xlm/client/client_test.go +++ b/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) diff --git a/chain/xrp/client/client_test.go b/chain/xrp/client/client_test.go index 31a1bf38..c5a4846a 100644 --- a/chain/xrp/client/client_test.go +++ b/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) diff --git a/ci/mult_transfer_test.go b/ci/mult_transfer_test.go index 790821f4..ddf97fcc 100644 --- a/ci/mult_transfer_test.go +++ b/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) diff --git a/ci/transfer_test.go b/ci/transfer_test.go index bdee05ce..d373124d 100644 --- a/ci/transfer_test.go +++ b/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) diff --git a/client/types/api.go b/client/types/api.go index a70e43c6..86db8cb4 100644 --- a/client/types/api.go +++ b/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 } diff --git a/cmd/xc/commands/submit.go b/cmd/xc/commands/submit.go index cc871daf..b9e1c7cf 100644 --- a/cmd/xc/commands/submit.go +++ b/cmd/xc/commands/submit.go @@ -27,7 +27,7 @@ func CmdRpcSubmit() *cobra.Command { } binaryTx := xctypes.NewBinaryTx(payload, nil) - req, err := xctypes.SubmitTxReqFromTx(binaryTx) + req, err := xctypes.SubmitTxReqFromTx(chainConfig.Chain, binaryTx) if err != nil { return fmt.Errorf("failed to convert to SubmitTxReq: %w", err) } diff --git a/cmd/xc/commands/transfer_multi.go b/cmd/xc/commands/transfer_multi.go index 1600e044..00295332 100644 --- a/cmd/xc/commands/transfer_multi.go +++ b/cmd/xc/commands/transfer_multi.go @@ -348,7 +348,7 @@ func CmdTxMultiTransfer() *cobra.Command { } // submit the tx, wait a bit, fetch the tx info (network needed) - req, err := xctypes.SubmitTxReqFromTx(tx) + req, err := xctypes.SubmitTxReqFromTx(chainConfig.Chain, tx) if err != nil { return fmt.Errorf("failed to convert tx to SubmitTxReq: %w", err) } diff --git a/cmd/xc/commands/tx_input.go b/cmd/xc/commands/tx_input.go index 68faf99c..9aa1a7dc 100644 --- a/cmd/xc/commands/tx_input.go +++ b/cmd/xc/commands/tx_input.go @@ -11,6 +11,7 @@ import ( "github.com/cordialsys/crosschain/builder" "github.com/cordialsys/crosschain/cmd/xc/setup" "github.com/cordialsys/crosschain/config" + "github.com/cordialsys/crosschain/factory/drivers" "github.com/cordialsys/crosschain/factory/signer" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -46,6 +47,12 @@ func CmdTxInput() *cobra.Command { return fmt.Errorf("must set --decimals if using --contract") } + // validate from address + err = drivers.ValidateAddress(chainConfig.Base(), fromAddress) + if err != nil { + return fmt.Errorf("invalid from address: %v", err) + } + client, err := xcFactory.NewClient(chainConfig) if err != nil { return err diff --git a/cmd/xc/staking/util.go b/cmd/xc/staking/util.go index 33d4b375..592cebdb 100644 --- a/cmd/xc/staking/util.go +++ b/cmd/xc/staking/util.go @@ -92,7 +92,7 @@ func SignAndMaybeBroadcast(xcFactory *factory.Factory, chain *xc.ChainConfig, si return "", fmt.Errorf("failed transaction resubmission") } - req, err := xctypes.SubmitTxReqFromTx(tx) + req, err := xctypes.SubmitTxReqFromTx(chain.Chain, tx) if err != nil { return "", fmt.Errorf("failed to convert tx to SubmitTxReq: %w", err) } diff --git a/examples/staking/kiln/kiln.go b/examples/staking/kiln/kiln.go index a82f6275..25917a39 100644 --- a/examples/staking/kiln/kiln.go +++ b/examples/staking/kiln/kiln.go @@ -168,7 +168,7 @@ func CmdStake() *cobra.Command { return nil } - req, err := xctypes.SubmitTxReqFromTx(tx) + req, err := xctypes.SubmitTxReqFromTx(chain.Chain, tx) if err != nil { return fmt.Errorf("failed to convert tx to req: %w", err) } @@ -309,7 +309,7 @@ func CmdUnstake() *cobra.Command { return nil } - req, err := xctypes.SubmitTxReqFromTx(tx) + req, err := xctypes.SubmitTxReqFromTx(chain.Chain, tx) if err != nil { return fmt.Errorf("failed to convert tx to req: %w", err) } diff --git a/examples/staking/solana/solana.go b/examples/staking/solana/solana.go index 6e06f71c..1a1fedf7 100644 --- a/examples/staking/solana/solana.go +++ b/examples/staking/solana/solana.go @@ -168,7 +168,7 @@ func CmdStake() *cobra.Command { fmt.Println("submitting hash ", solana.Signature(sig1.Signature).String(), "...") binTx := xctypes.NewBinaryTx(tzBz, nil) - req, err := xctypes.SubmitTxReqFromTx(binTx) + req, err := xctypes.SubmitTxReqFromTx(chain.Chain, binTx) if err != nil { return err }