Can sign and send transactions to moonbeam?

[YuXiaoCoder]

How do I sign and send a transaction to Moonbeam, I understand Polkadot's method!

// Transfer 转账 https://kusama.subscan.io/extrinsic?module=Balances&call=transfer_keep_alive
func (service *Service) Transfer(signer Signer, to types.AccountID, amount uint64) *types.Hash {
	// 获取元数据信息
	metadata := service.GetMetadata()
	if metadata == nil {
		return nil
	}

	toMultiAddress, err := types.NewMultiAddressFromAccountID(to.ToBytes())
	if err != nil {
		zap.S().Warnf("failed to get to [%v] multi address, err: %v", to.ToHexString(), err)
		return nil
	}

	// Transfer Call
	transferCall, err := types.NewCall(metadata, "Balances.transfer_keep_alive", toMultiAddress, types.NewUCompactFromUInt(amount))
	if err != nil {
		zap.S().Warnf("failed to new Balances.transfer_keep_alive call, err: %v", err)
		return nil
	}

	// Extrinsic
	extrinsic := types.NewExtrinsic(transferCall)

	if signer.IsProxy {
		proxyType := signer.ProxyType
		realAccount := signer.RealAccountId

		// 获取被代理账户的账户 ID
		realMultiAddress, err := types.NewMultiAddressFromAccountID(realAccount.ToBytes())
		if err != nil {
			zap.S().Warnf("failed to get real [%v] multi address, err: %v", realAccount.ToHexString(), err)
			return nil
		}

		call, err := types.NewCall(metadata, "Proxy.proxy", realMultiAddress, types.NewOption[byte](byte(proxyType)), transferCall)
		if err != nil {
			zap.S().Warnf("failed to new Proxy.proxy call, err: %v", err)
			return nil
		}

		// Extrinsic
		extrinsic = types.NewExtrinsic(call)
	}
	extrinsicByte, err := extrinsic.MarshalJSON()
	if err != nil {
		zap.S().Warnf("failed to unmarshal extrinsic, err: %v", err)
		return nil
	}
	zap.S().Infof("singer: %v, real account: %v, extrinsic: %v\n", signer.Origin.Address, signer.RealAccountId.ToHexString(), FormatExtrinsic(extrinsicByte))

	// 获取签名配置
	options := service.GetSignatureOptions(signer.Origin.PublicKey)
	if options == nil {
		return nil
	}

	// 对交易体签名
	err = extrinsic.Sign(signer.Origin, *options)
	if err != nil {
		zap.S().Warnf("failed to sign extrinsic, err: %v", err)
		return nil
	}

	// 提交交易并返回交易哈希
	txHash, err := service.Api.RPC.Author.SubmitExtrinsic(extrinsic)
	if err != nil {
		zap.S().Warnf("failed to submit extrinsic, err: %v", err)
		return nil
	}
	return &txHash
}

// 从助记词派生出密钥对
keypair, err := signature.KeyringPairFromSecret(mnemonic+derivationPath, uint16(networkId))
if err != nil {
        zap.S().Warnf("failed to derive key pair: %v", err)
        return nil
}

[cdamian]

@YuXiaoCoder Please check the following issue for more details about signing and submitting transactions:
#389

[YuXiaoCoder]

@YuXiaoCoder Please check the following issue for more details about signing and submitting transactions: #389

@cdamian

1. How should I generate the KeyringPair for the moonbeam network, should I continue to use sr25519.Scheme{} or ecdsa..Scheme{}
2. How should the derived path be written to correspond to the EVM address?（'/m/44'/60'/0'/0/0'）
3. The account id for the moonbeam network is 20 bytes long, not 32, so it runs exceptionally: panic: invalid account ID bytes
4. I'm a beginner, thanks a lot for being able to answer the stupid questions I'm asking, and if it's feasible, could you give me a full example? (including keypair generation, and example of signing and sending a transaction)

package main

import (
	"fmt"
	"math/big"

	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
	"github.com/centrifuge/go-substrate-rpc-client/v4/types/codec"
	"github.com/centrifuge/go-substrate-rpc-client/v4/types/extrinsic"
	"github.com/centrifuge/go-substrate-rpc-client/v4/types/extrinsic/extensions"
	"go.uber.org/zap"
)

func main() {
	mnemonic := "XXXXXX"

	// 从助记词派生出密钥对
	keypair, err := signature.KeyringPairFromSecret(mnemonic+"/m/44'/60'/0'/0/0", uint16(1284))
	if err != nil {
		zap.S().Warnf("failed to derive key pair: %v", err)
		return
	}
	fmt.Println(keypair.Address)

	// Instantiate the API
	api, err := gsrpc.NewSubstrateAPI("wss://moonriver-rpc.dwellir.com")
	if err != nil {
		panic(err)
	}

	meta, err := api.RPC.State.GetMetadataLatest()
	if err != nil {
		panic(err)
	}

	// Create a call, transferring 1e10 units to Bob
	bob, err := types.NewMultiAddressFromHexAccountID("0x80893554E58bBCCa39faA3d88573e88f94145d86")
	if err != nil {
		panic(err)
	}

	// 1 unit of transfer
	bal, ok := new(big.Int).SetString("1000000000000", 10)
	if !ok {
		panic(fmt.Errorf("failed to convert balance"))
	}

	c, err := types.NewCall(meta, "Balances.transfer_keep_alive", bob, types.NewUCompact(bal))
	if err != nil {
		panic(err)
	}

	ext := extrinsic.NewDynamicExtrinsic(&c)

	genesisHash, err := api.RPC.Chain.GetBlockHash(0)
	if err != nil {
		panic(err)
	}

	rv, err := api.RPC.State.GetRuntimeVersionLatest()
	if err != nil {
		panic(err)
	}

	key, err := types.CreateStorageKey(meta, "System", "Account", keypair.PublicKey)
	if err != nil {
		panic(err)
	}

	var accountInfo types.AccountInfo
	ok, err = api.RPC.State.GetStorageLatest(key, &accountInfo)
	if err != nil || !ok {
		panic(err)
	}

	err = ext.Sign(
		keypair,
		meta,
		extrinsic.WithEra(types.ExtrinsicEra{IsImmortalEra: true}, genesisHash),
		extrinsic.WithNonce(types.NewUCompactFromUInt(uint64(accountInfo.Nonce))),
		extrinsic.WithTip(types.NewUCompactFromUInt(0)),
		extrinsic.WithSpecVersion(rv.SpecVersion),
		extrinsic.WithTransactionVersion(rv.TransactionVersion),
		extrinsic.WithGenesisHash(genesisHash),
		extrinsic.WithMetadataMode(extensions.CheckMetadataModeDisabled, extensions.CheckMetadataHash{Hash: types.NewEmptyOption[types.H256]()}),
		extrinsic.WithAssetID(types.NewEmptyOption[types.AssetID]()),
	)

	if err != nil {
		panic(err)
	}

	encodedExt, err := codec.EncodeToHex(ext)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Ext - %s\n", encodedExt)

	sub, err := api.RPC.Author.SubmitAndWatchDynamicExtrinsic(ext)
	if err != nil {
		panic(err)
	}
	defer sub.Unsubscribe()

	for {
		select {
		case st := <-sub.Chan():
			extStatus, _ := st.MarshalJSON()
			fmt.Printf("Status for transaction - %s\n", string(extStatus))
		case err := <-sub.Err():
			panic(err)
		}
	}
}