Given this is only used in tests we could do something like this,

func HexToFelt(t testing.TB, hex string) *felt.Felt {
	t.Helper()
	f, err := new(felt.Felt).SetString(hex)
	require.NoError(t, err)
	return f
}

In general I would advise against ignoring errors in functions like this

Me too.
Also, for tests there's already the TestHexToFelt func that does exactly what you mentioned.

I thought about this function when we need to put some values that we have sure are valid felts (like addresses, hashes...) into (for e.g.) an object, and as the felt (for good reasons) returns an error in such operations we need to declare and set the variable previously. With this function we can set it directly. WDYT?

We should probably implement an interface defining the set of functions that the websocket provider must implement, basically something like
var _ RpcProvider = &Provider{}
for the websocket provider

Agree.
It is in my plans

We should set this as an ENV variable to be consistent with the other examples

Agree.
I'm currently using this file to test each endpoint I'm creating, but I'm not committing the changes.
Once I finish the features I'll make a proper example for websocket

If there was no error, we should unsubscribe when exiting main,
defer sub.Unsubscribe()

I think this README needs updated

Yes. I'll do this at the end

suggestion

func (provider *WsProvider) SubscribeEvents(ctx context.Context, events chan<- *EmittedEvent, input EventSubscriptionInput) (*client.ClientSubscription, error) {
	if input.BlockID.IsZero() {
		input.BlockID = BlockID{Tag: "latest"}
	}
	sub, err := provider.c.Subscribe(ctx, "starknet", "_subscribeEvents", events, input)
	if err != nil {
		return nil, tryUnwrapToRPCErr(err, ErrTooManyKeysInFilter, ErrTooManyBlocksBack, ErrBlockNotFound, ErrCallOnPending)
	}
	return sub, nil
}

Also, add the IsZero() method

func (b BlockID) IsZero() bool {
	return b == BlockID{}
}

Maybe, also just make the default BlockID a global varialbe (in types_block.go) and use that instead (probably cleaner)

var	DefaultBlockID = BlockID{Tag: "latest"}

Yeah, I know it defaults to "latest" even if we don't pass any blockID, but a json request with an empty param is different from a request passing values. The json will be different from the one requested by the user, even if the result is the same.
I just wanted to make the final json request exactly the one the user is creating in the code. WDYT?

Yeah that's a good point. Although, given an absent blockId is the same as the default value, I think overriding it is okay. Plus this approach is a bit neater, and less error prone imo

Please take a look at my new approach and let me know your opinion

maybe just return a "waiting for Juno to implement this method" error?

Because it'll be easier for me at the end to just uncomment the correct code and delete the other hahaha.
Hope you don't mind. I'll fix it anyway at the end

Why do we pass in the BlockID? Also, maybe we can just use a global BlockID as mentioned in the above comment?

This field is no longer accepted by this method according to the spec, but Juno hasn't implemented it yet when I wrote this. So I made this change to make it work normally and test it, but I'll revert it later

The Reorg notification was tested locally using a Juno node with a small modification.
To simulate reorg notifications, I changed the Juno code so that instead of waiting for the feeder to return the Reorg event, it'll send one every 5 seconds, along with the main subscription.

So, I subscribed to the SubscribeNewHeads method and the code handled perfectly both the main subscription and the ReorgEvents sents.