eth_clock

package
v1.9.7-0...-acf8c2f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 24, 2025 License: LGPL-3.0 Imports: 8 Imported by: 0

Documentation

Overview

Package eth_clock is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type EthereumClock 

type EthereumClock interface {
	GetSlotTime(slot uint64) time.Time
	GetCurrentSlot() uint64
	GetEpochAtSlot(slot uint64) uint64
	IsSlotCurrentSlotWithMaximumClockDisparity(slot uint64) bool
	GetSlotByTime(time time.Time) uint64
	GetCurrentEpoch() uint64
	CurrentForkDigest() (common.Bytes4, error)                             // ComputeForkDigest
	NextForkDigest() (common.Bytes4, error)                                // ComputeForkDigest
	ForkId() ([]byte, error)                                               // ComputeForkId
	LastFork() (common.Bytes4, error)                                      // GetLastFork
	StateVersionByForkDigest(common.Bytes4) (clparams.StateVersion, error) // ForkDigestVersion
	StateVersionByEpoch(uint64) clparams.StateVersion
	ComputeForkDigestForVersion(currentVersion common.Bytes4) (digest common.Bytes4, err error)

	GenesisValidatorsRoot() common.Hash
	GenesisTime() uint64
}

func NewEthereumClock 

func NewEthereumClock(genesisTime uint64, genesisValidatorsRoot common.Hash, beaconCfg *clparams.BeaconChainConfig) EthereumClock

type MockEthereumClock 

type MockEthereumClock struct {
	// contains filtered or unexported fields
}

MockEthereumClock is a mock of EthereumClock interface.

func NewMockEthereumClock 

func NewMockEthereumClock(ctrl *gomock.Controller) *MockEthereumClock

NewMockEthereumClock creates a new mock instance.

func (*MockEthereumClock) ComputeForkDigestForVersion 

func (m *MockEthereumClock) ComputeForkDigestForVersion(currentVersion common.Bytes4) (common.Bytes4, error)

ComputeForkDigestForVersion mocks base method.

func (*MockEthereumClock) CurrentForkDigest 

func (m *MockEthereumClock) CurrentForkDigest() (common.Bytes4, error)

CurrentForkDigest mocks base method.

func (*MockEthereumClock) EXPECT 

func (m *MockEthereumClock) EXPECT() *MockEthereumClockMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockEthereumClock) ForkId 

func (m *MockEthereumClock) ForkId() ([]byte, error)

ForkId mocks base method.

func (*MockEthereumClock) GenesisTime 

func (m *MockEthereumClock) GenesisTime() uint64

GenesisTime mocks base method.

func (*MockEthereumClock) GenesisValidatorsRoot 

func (m *MockEthereumClock) GenesisValidatorsRoot() common.Hash

GenesisValidatorsRoot mocks base method.

func (*MockEthereumClock) GetCurrentEpoch 

func (m *MockEthereumClock) GetCurrentEpoch() uint64

GetCurrentEpoch mocks base method.

func (*MockEthereumClock) GetCurrentSlot 

func (m *MockEthereumClock) GetCurrentSlot() uint64

GetCurrentSlot mocks base method.

func (*MockEthereumClock) GetEpochAtSlot 

func (m *MockEthereumClock) GetEpochAtSlot(slot uint64) uint64

GetEpochAtSlot mocks base method.

func (*MockEthereumClock) GetSlotByTime 

func (m *MockEthereumClock) GetSlotByTime(time time.Time) uint64

GetSlotByTime mocks base method.

func (*MockEthereumClock) GetSlotTime 

func (m *MockEthereumClock) GetSlotTime(slot uint64) time.Time

GetSlotTime mocks base method.

func (*MockEthereumClock) IsSlotCurrentSlotWithMaximumClockDisparity 

func (m *MockEthereumClock) IsSlotCurrentSlotWithMaximumClockDisparity(slot uint64) bool

IsSlotCurrentSlotWithMaximumClockDisparity mocks base method.

func (*MockEthereumClock) LastFork 

func (m *MockEthereumClock) LastFork() (common.Bytes4, error)

LastFork mocks base method.

func (*MockEthereumClock) NextForkDigest 

func (m *MockEthereumClock) NextForkDigest() (common.Bytes4, error)

NextForkDigest mocks base method.

func (*MockEthereumClock) StateVersionByEpoch 

func (m *MockEthereumClock) StateVersionByEpoch(arg0 uint64) clparams.StateVersion

StateVersionByEpoch mocks base method.

func (*MockEthereumClock) StateVersionByForkDigest 

func (m *MockEthereumClock) StateVersionByForkDigest(arg0 common.Bytes4) (clparams.StateVersion, error)

StateVersionByForkDigest mocks base method.

type MockEthereumClockComputeForkDigestForVersionCall 

type MockEthereumClockComputeForkDigestForVersionCall struct {
	*gomock.Call
}

MockEthereumClockComputeForkDigestForVersionCall wrap *gomock.Call

func (*MockEthereumClockComputeForkDigestForVersionCall) Do 

func (c *MockEthereumClockComputeForkDigestForVersionCall) Do(f func(common.Bytes4) (common.Bytes4, error)) *MockEthereumClockComputeForkDigestForVersionCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockComputeForkDigestForVersionCall) DoAndReturn 

func (c *MockEthereumClockComputeForkDigestForVersionCall) DoAndReturn(f func(common.Bytes4) (common.Bytes4, error)) *MockEthereumClockComputeForkDigestForVersionCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockComputeForkDigestForVersionCall) Return 

func (c *MockEthereumClockComputeForkDigestForVersionCall) Return(digest common.Bytes4, err error) *MockEthereumClockComputeForkDigestForVersionCall

Return rewrite *gomock.Call.Return

type MockEthereumClockCurrentForkDigestCall 

type MockEthereumClockCurrentForkDigestCall struct {
	*gomock.Call
}

MockEthereumClockCurrentForkDigestCall wrap *gomock.Call

func (*MockEthereumClockCurrentForkDigestCall) Do 

func (c *MockEthereumClockCurrentForkDigestCall) Do(f func() (common.Bytes4, error)) *MockEthereumClockCurrentForkDigestCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockCurrentForkDigestCall) DoAndReturn 

func (c *MockEthereumClockCurrentForkDigestCall) DoAndReturn(f func() (common.Bytes4, error)) *MockEthereumClockCurrentForkDigestCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockCurrentForkDigestCall) Return 

func (c *MockEthereumClockCurrentForkDigestCall) Return(arg0 common.Bytes4, arg1 error) *MockEthereumClockCurrentForkDigestCall

Return rewrite *gomock.Call.Return

type MockEthereumClockForkIdCall 

type MockEthereumClockForkIdCall struct {
	*gomock.Call
}

MockEthereumClockForkIdCall wrap *gomock.Call

func (*MockEthereumClockForkIdCall) Do 

func (c *MockEthereumClockForkIdCall) Do(f func() ([]byte, error)) *MockEthereumClockForkIdCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockForkIdCall) DoAndReturn 

func (c *MockEthereumClockForkIdCall) DoAndReturn(f func() ([]byte, error)) *MockEthereumClockForkIdCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockForkIdCall) Return 

func (c *MockEthereumClockForkIdCall) Return(arg0 []byte, arg1 error) *MockEthereumClockForkIdCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGenesisTimeCall 

type MockEthereumClockGenesisTimeCall struct {
	*gomock.Call
}

MockEthereumClockGenesisTimeCall wrap *gomock.Call

func (*MockEthereumClockGenesisTimeCall) Do 

func (c *MockEthereumClockGenesisTimeCall) Do(f func() uint64) *MockEthereumClockGenesisTimeCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGenesisTimeCall) DoAndReturn 

func (c *MockEthereumClockGenesisTimeCall) DoAndReturn(f func() uint64) *MockEthereumClockGenesisTimeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGenesisTimeCall) Return 

func (c *MockEthereumClockGenesisTimeCall) Return(arg0 uint64) *MockEthereumClockGenesisTimeCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGenesisValidatorsRootCall 

type MockEthereumClockGenesisValidatorsRootCall struct {
	*gomock.Call
}

MockEthereumClockGenesisValidatorsRootCall wrap *gomock.Call

func (*MockEthereumClockGenesisValidatorsRootCall) Do 

func (c *MockEthereumClockGenesisValidatorsRootCall) Do(f func() common.Hash) *MockEthereumClockGenesisValidatorsRootCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGenesisValidatorsRootCall) DoAndReturn 

func (c *MockEthereumClockGenesisValidatorsRootCall) DoAndReturn(f func() common.Hash) *MockEthereumClockGenesisValidatorsRootCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGenesisValidatorsRootCall) Return 

func (c *MockEthereumClockGenesisValidatorsRootCall) Return(arg0 common.Hash) *MockEthereumClockGenesisValidatorsRootCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGetCurrentEpochCall 

type MockEthereumClockGetCurrentEpochCall struct {
	*gomock.Call
}

MockEthereumClockGetCurrentEpochCall wrap *gomock.Call

func (*MockEthereumClockGetCurrentEpochCall) Do 

func (c *MockEthereumClockGetCurrentEpochCall) Do(f func() uint64) *MockEthereumClockGetCurrentEpochCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGetCurrentEpochCall) DoAndReturn 

func (c *MockEthereumClockGetCurrentEpochCall) DoAndReturn(f func() uint64) *MockEthereumClockGetCurrentEpochCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGetCurrentEpochCall) Return 

func (c *MockEthereumClockGetCurrentEpochCall) Return(arg0 uint64) *MockEthereumClockGetCurrentEpochCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGetCurrentSlotCall 

type MockEthereumClockGetCurrentSlotCall struct {
	*gomock.Call
}

MockEthereumClockGetCurrentSlotCall wrap *gomock.Call

func (*MockEthereumClockGetCurrentSlotCall) Do 

func (c *MockEthereumClockGetCurrentSlotCall) Do(f func() uint64) *MockEthereumClockGetCurrentSlotCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGetCurrentSlotCall) DoAndReturn 

func (c *MockEthereumClockGetCurrentSlotCall) DoAndReturn(f func() uint64) *MockEthereumClockGetCurrentSlotCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGetCurrentSlotCall) Return 

func (c *MockEthereumClockGetCurrentSlotCall) Return(arg0 uint64) *MockEthereumClockGetCurrentSlotCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGetEpochAtSlotCall 

type MockEthereumClockGetEpochAtSlotCall struct {
	*gomock.Call
}

MockEthereumClockGetEpochAtSlotCall wrap *gomock.Call

func (*MockEthereumClockGetEpochAtSlotCall) Do 

func (c *MockEthereumClockGetEpochAtSlotCall) Do(f func(uint64) uint64) *MockEthereumClockGetEpochAtSlotCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGetEpochAtSlotCall) DoAndReturn 

func (c *MockEthereumClockGetEpochAtSlotCall) DoAndReturn(f func(uint64) uint64) *MockEthereumClockGetEpochAtSlotCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGetEpochAtSlotCall) Return 

func (c *MockEthereumClockGetEpochAtSlotCall) Return(arg0 uint64) *MockEthereumClockGetEpochAtSlotCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGetSlotByTimeCall 

type MockEthereumClockGetSlotByTimeCall struct {
	*gomock.Call
}

MockEthereumClockGetSlotByTimeCall wrap *gomock.Call

func (*MockEthereumClockGetSlotByTimeCall) Do 

func (c *MockEthereumClockGetSlotByTimeCall) Do(f func(time.Time) uint64) *MockEthereumClockGetSlotByTimeCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGetSlotByTimeCall) DoAndReturn 

func (c *MockEthereumClockGetSlotByTimeCall) DoAndReturn(f func(time.Time) uint64) *MockEthereumClockGetSlotByTimeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGetSlotByTimeCall) Return 

func (c *MockEthereumClockGetSlotByTimeCall) Return(arg0 uint64) *MockEthereumClockGetSlotByTimeCall

Return rewrite *gomock.Call.Return

type MockEthereumClockGetSlotTimeCall 

type MockEthereumClockGetSlotTimeCall struct {
	*gomock.Call
}

MockEthereumClockGetSlotTimeCall wrap *gomock.Call

func (*MockEthereumClockGetSlotTimeCall) Do 

func (c *MockEthereumClockGetSlotTimeCall) Do(f func(uint64) time.Time) *MockEthereumClockGetSlotTimeCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockGetSlotTimeCall) DoAndReturn 

func (c *MockEthereumClockGetSlotTimeCall) DoAndReturn(f func(uint64) time.Time) *MockEthereumClockGetSlotTimeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockGetSlotTimeCall) Return 

func (c *MockEthereumClockGetSlotTimeCall) Return(arg0 time.Time) *MockEthereumClockGetSlotTimeCall

Return rewrite *gomock.Call.Return

type MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall 

type MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall struct {
	*gomock.Call
}

MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall wrap *gomock.Call

func (*MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) Do 

func (c *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) Do(f func(uint64) bool) *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) DoAndReturn 

func (c *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) DoAndReturn(f func(uint64) bool) *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) Return 

func (c *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall) Return(arg0 bool) *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall

Return rewrite *gomock.Call.Return

type MockEthereumClockLastForkCall 

type MockEthereumClockLastForkCall struct {
	*gomock.Call
}

MockEthereumClockLastForkCall wrap *gomock.Call

func (*MockEthereumClockLastForkCall) Do 

func (c *MockEthereumClockLastForkCall) Do(f func() (common.Bytes4, error)) *MockEthereumClockLastForkCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockLastForkCall) DoAndReturn 

func (c *MockEthereumClockLastForkCall) DoAndReturn(f func() (common.Bytes4, error)) *MockEthereumClockLastForkCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockLastForkCall) Return 

func (c *MockEthereumClockLastForkCall) Return(arg0 common.Bytes4, arg1 error) *MockEthereumClockLastForkCall

Return rewrite *gomock.Call.Return

type MockEthereumClockMockRecorder 

type MockEthereumClockMockRecorder struct {
	// contains filtered or unexported fields
}

MockEthereumClockMockRecorder is the mock recorder for MockEthereumClock.

func (*MockEthereumClockMockRecorder) ComputeForkDigestForVersion 

func (mr *MockEthereumClockMockRecorder) ComputeForkDigestForVersion(currentVersion any) *MockEthereumClockComputeForkDigestForVersionCall

ComputeForkDigestForVersion indicates an expected call of ComputeForkDigestForVersion.

func (*MockEthereumClockMockRecorder) CurrentForkDigest 

func (mr *MockEthereumClockMockRecorder) CurrentForkDigest() *MockEthereumClockCurrentForkDigestCall

CurrentForkDigest indicates an expected call of CurrentForkDigest.

func (*MockEthereumClockMockRecorder) ForkId 

func (mr *MockEthereumClockMockRecorder) ForkId() *MockEthereumClockForkIdCall

ForkId indicates an expected call of ForkId.

func (*MockEthereumClockMockRecorder) GenesisTime 

func (mr *MockEthereumClockMockRecorder) GenesisTime() *MockEthereumClockGenesisTimeCall

GenesisTime indicates an expected call of GenesisTime.

func (*MockEthereumClockMockRecorder) GenesisValidatorsRoot 

func (mr *MockEthereumClockMockRecorder) GenesisValidatorsRoot() *MockEthereumClockGenesisValidatorsRootCall

GenesisValidatorsRoot indicates an expected call of GenesisValidatorsRoot.

func (*MockEthereumClockMockRecorder) GetCurrentEpoch 

func (mr *MockEthereumClockMockRecorder) GetCurrentEpoch() *MockEthereumClockGetCurrentEpochCall

GetCurrentEpoch indicates an expected call of GetCurrentEpoch.

func (*MockEthereumClockMockRecorder) GetCurrentSlot 

func (mr *MockEthereumClockMockRecorder) GetCurrentSlot() *MockEthereumClockGetCurrentSlotCall

GetCurrentSlot indicates an expected call of GetCurrentSlot.

func (*MockEthereumClockMockRecorder) GetEpochAtSlot 

func (mr *MockEthereumClockMockRecorder) GetEpochAtSlot(slot any) *MockEthereumClockGetEpochAtSlotCall

GetEpochAtSlot indicates an expected call of GetEpochAtSlot.

func (*MockEthereumClockMockRecorder) GetSlotByTime 

func (mr *MockEthereumClockMockRecorder) GetSlotByTime(time any) *MockEthereumClockGetSlotByTimeCall

GetSlotByTime indicates an expected call of GetSlotByTime.

func (*MockEthereumClockMockRecorder) GetSlotTime 

func (mr *MockEthereumClockMockRecorder) GetSlotTime(slot any) *MockEthereumClockGetSlotTimeCall

GetSlotTime indicates an expected call of GetSlotTime.

func (*MockEthereumClockMockRecorder) IsSlotCurrentSlotWithMaximumClockDisparity 

func (mr *MockEthereumClockMockRecorder) IsSlotCurrentSlotWithMaximumClockDisparity(slot any) *MockEthereumClockIsSlotCurrentSlotWithMaximumClockDisparityCall

IsSlotCurrentSlotWithMaximumClockDisparity indicates an expected call of IsSlotCurrentSlotWithMaximumClockDisparity.

func (*MockEthereumClockMockRecorder) LastFork 

func (mr *MockEthereumClockMockRecorder) LastFork() *MockEthereumClockLastForkCall

LastFork indicates an expected call of LastFork.

func (*MockEthereumClockMockRecorder) NextForkDigest 

func (mr *MockEthereumClockMockRecorder) NextForkDigest() *MockEthereumClockNextForkDigestCall

NextForkDigest indicates an expected call of NextForkDigest.

func (*MockEthereumClockMockRecorder) StateVersionByEpoch 

func (mr *MockEthereumClockMockRecorder) StateVersionByEpoch(arg0 any) *MockEthereumClockStateVersionByEpochCall

StateVersionByEpoch indicates an expected call of StateVersionByEpoch.

func (*MockEthereumClockMockRecorder) StateVersionByForkDigest 

func (mr *MockEthereumClockMockRecorder) StateVersionByForkDigest(arg0 any) *MockEthereumClockStateVersionByForkDigestCall

StateVersionByForkDigest indicates an expected call of StateVersionByForkDigest.

type MockEthereumClockNextForkDigestCall 

type MockEthereumClockNextForkDigestCall struct {
	*gomock.Call
}

MockEthereumClockNextForkDigestCall wrap *gomock.Call

func (*MockEthereumClockNextForkDigestCall) Do 

func (c *MockEthereumClockNextForkDigestCall) Do(f func() (common.Bytes4, error)) *MockEthereumClockNextForkDigestCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockNextForkDigestCall) DoAndReturn 

func (c *MockEthereumClockNextForkDigestCall) DoAndReturn(f func() (common.Bytes4, error)) *MockEthereumClockNextForkDigestCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockNextForkDigestCall) Return 

func (c *MockEthereumClockNextForkDigestCall) Return(arg0 common.Bytes4, arg1 error) *MockEthereumClockNextForkDigestCall

Return rewrite *gomock.Call.Return

type MockEthereumClockStateVersionByEpochCall 

type MockEthereumClockStateVersionByEpochCall struct {
	*gomock.Call
}

MockEthereumClockStateVersionByEpochCall wrap *gomock.Call

func (*MockEthereumClockStateVersionByEpochCall) Do 

func (c *MockEthereumClockStateVersionByEpochCall) Do(f func(uint64) clparams.StateVersion) *MockEthereumClockStateVersionByEpochCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockStateVersionByEpochCall) DoAndReturn 

func (c *MockEthereumClockStateVersionByEpochCall) DoAndReturn(f func(uint64) clparams.StateVersion) *MockEthereumClockStateVersionByEpochCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockStateVersionByEpochCall) Return 

func (c *MockEthereumClockStateVersionByEpochCall) Return(arg0 clparams.StateVersion) *MockEthereumClockStateVersionByEpochCall

Return rewrite *gomock.Call.Return

type MockEthereumClockStateVersionByForkDigestCall 

type MockEthereumClockStateVersionByForkDigestCall struct {
	*gomock.Call
}

MockEthereumClockStateVersionByForkDigestCall wrap *gomock.Call

func (*MockEthereumClockStateVersionByForkDigestCall) Do 

func (c *MockEthereumClockStateVersionByForkDigestCall) Do(f func(common.Bytes4) (clparams.StateVersion, error)) *MockEthereumClockStateVersionByForkDigestCall

Do rewrite *gomock.Call.Do

func (*MockEthereumClockStateVersionByForkDigestCall) DoAndReturn 

func (c *MockEthereumClockStateVersionByForkDigestCall) DoAndReturn(f func(common.Bytes4) (clparams.StateVersion, error)) *MockEthereumClockStateVersionByForkDigestCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEthereumClockStateVersionByForkDigestCall) Return 

func (c *MockEthereumClockStateVersionByForkDigestCall) Return(arg0 clparams.StateVersion, arg1 error) *MockEthereumClockStateVersionByForkDigestCall

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.