DecodeEventRecords function throw an err for "Encoded array length is higher than allowed by the protocol (32-bit unsigned integer)"

[glant509]

    types.EventRecordsRaw(*storageDataRaw).DecodeEventRecords(metadata, &events0) has a err for "Encoded array length is higher than allowed by the protocol (32-bit unsigned integer)"

   the err appear at codec.go, because the event System_ExtrinsicSuccess.DispatchInfo.Weight.RefTime is a uint64 format, but the sdk restricted to uint32, when it over uint32, there will be return this err.  in my test code, the blockNumber(number) is 12472776

my code detail is:

import (
"encoding/hex"
"encoding/json"
"fmt"
gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
"github.com/centrifuge/go-substrate-rpc-client/v4/registry"
"github.com/centrifuge/go-substrate-rpc-client/v4/registry/parser"
"github.com/centrifuge/go-substrate-rpc-client/v4/registry/state"
"github.com/centrifuge/go-substrate-rpc-client/v4/types"
"github.com/centrifuge/go-substrate-rpc-client/v4/types/codec"
"github.com/vedhavyas/go-subkey/v2"
"io/ioutil"
"net/http"
"strconv"
"strings"
)
func getEvents(number int, hash, url string) {
api, err := gsrpc.NewSubstrateAPI(url)
if err != nil {
panic("NewSubstrateAPI")
}

blockLatest, err := api.RPC.Chain.GetBlockLatest()
if err != nil {
	panic("api.RPC.Chain.GetBlockLatest()")
}

header := blockLatest.Block.Header
extrinsics := blockLatest.Block.Extrinsics

fmt.Println(header.Number, len(extrinsics))

blockHash, err := api.RPC.Chain.GetBlockHash(uint64(number))
if err != nil {
	panic("api.RPC.Chain.GetBlockHash(uint64(header.Number)")
}
fmt.Println("block_hash", hex.EncodeToString(blockHash[:]))

metadata, err := api.RPC.State.GetMetadata(blockHash)
if err != nil {
	panic("api.RPC.State.GetMetadata(blockHash)")
}

storageKey, err := types.CreateStorageKey(metadata, "System", "Events")
if err != nil {
	panic("types.CreateStorageKey")
}
storageDataRaw, err := api.RPC.State.GetStorageRaw(storageKey, blockHash)
if err != nil {
	panic("api.RPC.State.GetStorageRaw")
}

events0 := types.EventRecords{}
err = types.EventRecordsRaw(*storageDataRaw).DecodeEventRecords(metadata, &events0)
if err != nil {
	panic(err)
}

fmt.Println(events0)

}

call the func getEvents in a main func like this:

func main() {
getEvents(12472776, "hash", "https://docs-demo.dot-mainnet.quiknode.pro/")
}