SubmitExtrinsic Verification Error

[jekabolt]

Im using chain DataHighway Tanganika Kusama Parachain using DataHighway Collator v3.6.0-b938f49-x86_64-linux-gnu

trying to SubmitExtrinsic

my code below

func TestTransfer(t *testing.T) {
	// This sample shows how to create a transaction to make a transfer from one an account to another.

	// Instantiate the API
	api, err := gsrpc.NewSubstrateAPI("wss://tanganika.datahighway.com")
	if err != nil {
		panic(err)
	}

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

	kpFrom, err := signature.KeyringPairFromSecret("secret1", 33)
	assert.NoError(t, err)

	kpTo, err := signature.KeyringPairFromSecret("secret2", 33)
	assert.NoError(t, err)

	addrTo, err := types.NewMultiAddressFromHexAccountID(types.HexEncodeToString(kpTo.PublicKey))

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

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

	// Create the extrinsic
	ext := types.NewExtrinsic(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", kpFrom.PublicKey)
	if err != nil {
		panic(err)
	}

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

	nonce := uint32(accountInfo.Nonce)
	o := types.SignatureOptions{
		BlockHash:          genesisHash,
		Era:                types.ExtrinsicEra{IsMortalEra: false},
		GenesisHash:        genesisHash,
		Nonce:              types.NewUCompactFromUInt(uint64(nonce)),
		SpecVersion:        rv.SpecVersion,
		Tip:                types.NewUCompactFromUInt(100),
		TransactionVersion: rv.TransactionVersion,
	}

	// Sign the transaction using Alice's default account
	err = ext.Sign(kpFrom, o)
	if err != nil {
		panic(err)
	}

	enc, err := types.EncodeToHex(ext)
	if err != nil {
		panic(err)
	}
	fmt.Println("tx --- ", enc)
	// Send the extrinsic
	_, err = api.RPC.Author.SubmitExtrinsic(ext)
	if err != nil {
		t.Errorf("SubmitExtrinsic %v", err)
	}

}

Im getting

SubmitExtrinsic Verification Error: Runtime error: Execution failed: Execution aborted due to trap: wasm trap: wasm `unreachable` instruction executed
        WASM backtrace:

            0: 0x324fa5 - <unknown>!rust_begin_unwind
            1: 0x35bc - <unknown>!core::panicking::panic_fmt::h8f11323637b4db3b
            2: 0x21812f - <unknown>!TaggedTransactionQueue_validate_transaction

any ideas what is wrong

[sheenhx]

We solved this by decode the correct tx signed message from PolkadotJS.
And we found out the go-rpc code writes the TX message in a wrong sequence

0x390284005675bfca5d558c0df741ce6017beb274d97f262144441f8d622f7e62bb0e411c0168d01fbd9c7849bfdb51cde9d7a3494e1e7af22160f2a361f3672168f5d9085db91a24ea9d9a9d3c9bdaa8f7a347c28a0e4f930aa7e8f0af484547086b9aca89002400000f00009425ad96a3583bfe7de1f0a722ee7bbe9ddcaf3b4b79468ca74fe1b6b99c540c0284d717

https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Ftanganika.datahighway.com#/extrinsics/decode

After sorting it right, we can submit this extrinsic correctly.

[jekabolt]

@sheenhx Hey I didn't get what do you mean
I found that SectionIndex & MethodIndex are in wrong places
and for browser generated tx they push SectionIndex in front of args

func NewCall(m *types.Metadata, call string, args ...interface{}) (types.Call, error) {
	c, err := m.FindCallIndex(call)
	if err != nil {
		return types.Call{}, err
	}
	c = types.CallIndex{
		SectionIndex: c.MethodIndex,
		MethodIndex:  c.SectionIndex,
	}

	var a []byte
	ci, err := types.Encode(c.SectionIndex)
	if err != nil {
		return types.Call{}, err
	}
	a = append(a, ci...)

	for _, arg := range args {
		e, err := types.Encode(arg)
		if err != nil {
			return types.Call{}, err
		}
		a = append(a, e...)
	}

	return types.Call{
		CallIndex: c,
		Args:      a,
	}, nil
}

here I got two nearly identical txs

0x4d028400d624d7a4c7ad34cdd007428709b610d529649e273567c4d7ea37854cec44152601f0a0af61cfc657295bc22cb93e07272b00679edbc21d3cfeb9d188782d5fcd6a9f448bb998109b98a3461e037a915f6596e71b2f646bcb48bc14ba6cb0d49389002800000f00005675bfca5d558c0df741ce6017beb274d97f262144441f8d622f7e62bb0e411c13000064a7b3b6e00d ```
this one from browser 

0x4d028400d624d7a4c7ad34cdd007428709b610d529649e273567c4d7ea37854cec441526011232c17b4a23edfeb8cda558721c8892af458ceccf0e17a618d31f6c7a66d43d64ddcaed7fa1cbe0593fd340958c7129ac9ca10eac86ff8f8fff7715cd5cf884002800000f00005675bfca5d558c0df741ce6017beb274d97f262144441f8d622f7e62bb0e411c13000064a7b3b6e00d```

and one I generate from code only difference in them is sig field
and if I try to submit em via browser it gives error :

1010: Invalid Transaction: Transaction has a bad signature

[jekabolt]

@sheenhx I took payload from generated tx

payload 0x000f00005675bfca5d558c0df741ce6017beb274d97f262144441f8d622f7e62bb0e411c13000064a7b3b6e00d0028000400000001000000eacdd2d5b42de9769ccbb6e8d9013ab0d90ab105bf601d4aac53e874c145ec21eacdd2d5b42de9769ccbb6e8d9013ab0d90ab105bf601d4aac53e874c145

and signature

0x1232c17b4a23edfeb8cda558721c8892af458ceccf0e17a618d31f6c7a66d43d64ddcaed7fa1cbe0593fd340958c7129ac9ca10eac86ff8f8fff7715cd5cf884

they are totally fine and pass

ok, err := signature.Verify(b, sig[:], signature.TestKeyringPairAlice.URI)

and browser verification

[jekabolt]

How can I resolve this error?

Thanks

[CocDap]

I have the same issue. Any solutions?
I am using the latest version 4.1.0

My blockchain node version: polkadot-v0.9.36
This is my code example:

package main

import (
	"fmt"
	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"

)

func main(){
	err := SendData();

	if err != nil {
		fmt.Println("error:",err)
	
	}

}


func SendData() error {
        //Alice private key 
	nemo := "0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a"

	api, err := gsrpc.NewSubstrateAPI("ws://127.0.0.1:9944")
	if err != nil {
		return err
	}
	fmt.Println("connected")

	keypair, err := signature.KeyringPairFromSecret(nemo, 42)
	fmt.Println("keypair", keypair.Address, keypair.PublicKey, keypair.URI)
	if err != nil {
		fmt.Println("keypair", err)
	}
	meta, err := api.RPC.State.GetMetadataLatest()
	if err != nil {
		return err
	}

	amount := types.NewUCompactFromUInt(2000000000000000000)

	bob, err := types.NewMultiAddressFromHexAccountID("0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48")
	c, err := types.NewCall(meta, "Balances.transfer",bob, amount)
	if err != nil {
		fmt.Println("err call", err)
		return err
	}
	fmt.Println("done1")
	// Create the extrinsic
	ext := types.NewExtrinsic(c)
	fmt.Println("ext:",ext.Version)


	genesisHash, err := api.RPC.Chain.GetBlockHash(0)
	if err != nil {
		fmt.Println("genesisHash, err", err)
		return err
	}
	fmt.Println("done 2 genesisHash", genesisHash)
	rv, err := api.RPC.State.GetRuntimeVersionLatest()
	if err != nil {
		fmt.Println("GetRuntimeVersionLatest, err", err)
		return err
	}
	fmt.Println("done 3")
	key, err := types.CreateStorageKey(meta, "System", "Account", keypair.PublicKey)
	if err != nil {
		return err
	}
	fmt.Println("done 4 key ", key)
	var accountInfo types.AccountInfo
	ok, err := api.RPC.State.GetStorageLatest(key, &accountInfo)
	fmt.Println("done 5", ok, err, accountInfo)
	if err != nil || !ok {
		return err
	}

	nonce := uint32(accountInfo.Nonce)
	o := types.SignatureOptions{
		BlockHash:          genesisHash,
		Era:                types.ExtrinsicEra{IsMortalEra: false},
		GenesisHash:        genesisHash,
		Nonce:              types.NewUCompactFromUInt(uint64(nonce)),
		SpecVersion:        rv.SpecVersion,
		Tip:                types.NewUCompactFromUInt(100),
		TransactionVersion: rv.TransactionVersion,
	}
	fmt.Println("before sign:",o)
	// Sign the transaction using Alice's default account
	err = ext.Sign(keypair, o)
	if err != nil {
		return err
	}
	fmt.Println("before submission")
	// Send the extrinsic
	txnHash, err := api.RPC.Author.SubmitAndWatchExtrinsic(ext)
	if err != nil {
		return err
	}
	fmt.Println("after submission txnHash", txnHash)
	return nil
}

My go.mod

module test-sign-transaction

go 1.18

require github.com/centrifuge/go-substrate-rpc-client/v4 v4.1.0

require (
	github.com/ChainSafe/go-schnorrkel v1.0.0 // indirect
	github.com/cosmos/go-bip39 v1.0.0 // indirect
	github.com/deckarep/golang-set v1.8.0 // indirect
	github.com/decred/base58 v1.0.4 // indirect
	github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
	github.com/ethereum/go-ethereum v1.10.20 // indirect
	github.com/go-stack/stack v1.8.1 // indirect
	github.com/gorilla/websocket v1.5.0 // indirect
	github.com/gtank/merlin v0.1.1 // indirect
	github.com/gtank/ristretto255 v0.1.2 // indirect
	github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b // indirect
	github.com/pierrec/xxHash v0.1.5 // indirect
	github.com/rs/cors v1.8.2 // indirect
	github.com/vedhavyas/go-subkey v1.0.4 // indirect
	golang.org/x/crypto v0.7.0 // indirect
	golang.org/x/sys v0.6.0 // indirect
	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
)

[cdamian]

It could be that other chains use different kind of tips for signature options, or different signatures, one example can be found here - https://github.com/centrifuge/go-substrate-rpc-client/blob/master/registry/retriever/extrinsic_retriever_live_test.go#L24

The polkadot JS endpoint that you provided, https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Ftanganika.datahighway.com#/extrinsics/decode, does not seem to work. Is there another endpoint that we can use to check this particular issue?