bindings.go

// This file was generated by seer: https://github.com/moonstream-to/seer.
// seer version: 0.0.5
// seer command: seer starknet abigentypes --package main
// Warning: Edit at your own risk. Any edits you make will NOT survive the next code generation.

package main

import (
	"context"
	"encoding/hex"
	"encoding/json"
	"errors"
	"math/big"
	"time"

	"github.com/NethermindEth/juno/core/felt"
	"github.com/NethermindEth/starknet.go/rpc"
	"github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
)

var ErrIncorrectParameters error = errors.New("incorrect parameters")

func ParseUint64(parameters []*felt.Felt) (uint64, int, error) {
	if len(parameters) < 1 {
		return 0, 0, ErrIncorrectParameters
	}
	return parameters[0].Uint64(), 1, nil
}

func ParseBigInt(parameters []*felt.Felt) (*big.Int, int, error) {
	if len(parameters) < 1 {
		return nil, 0, ErrIncorrectParameters
	}
	result := big.NewInt(0)
	result = parameters[0].BigInt(result)
	return result, 1, nil
}

func ParseString(parameters []*felt.Felt) (string, int, error) {
	if len(parameters) < 1 {
		return "", 0, ErrIncorrectParameters
	}
	return parameters[0].String(), 1, nil
}

func ParseArray[T any](parser func(parameters []*felt.Felt) (T, int, error)) func(parameters []*felt.Felt) ([]T, int, error) {
	return func(parameters []*felt.Felt) ([]T, int, error) {
		if len(parameters) < 1 {
			return nil, 0, ErrIncorrectParameters
		}

		arrayLengthRaw := parameters[0].Uint64()
		arrayLength := int(arrayLengthRaw)
		if len(parameters) < arrayLength+1 {
			return nil, 0, ErrIncorrectParameters
		}

		result := make([]T, arrayLength)
		currentIndex := 1
		for i := 0; i < arrayLength; i++ {
			parsed, consumed, err := parser(parameters[currentIndex:])
			if err != nil {
				return nil, 0, err
			}
			result[i] = parsed
			currentIndex += consumed
		}

		return result, currentIndex, nil
	}
}

var ErrIncorrectEventKey error = errors.New("incorrect event key")

type RawEvent struct {
	BlockNumber     uint64
	BlockHash       *felt.Felt
	TransactionHash *felt.Felt
	FromAddress     *felt.Felt
	PrimaryKey      *felt.Felt
	Keys            []*felt.Felt
	Parameters      []*felt.Felt
}

func FeltFromHexString(hexString string) (*felt.Felt, error) {
	fieldAdditiveIdentity := fp.NewElement(0)

	if hexString[:2] == "0x" {
		hexString = hexString[2:]
	}
	decodedString, decodeErr := hex.DecodeString(hexString)
	if decodeErr != nil {
		return nil, decodeErr
	}
	derivedFelt := felt.NewFelt(&fieldAdditiveIdentity)
	derivedFelt.SetBytes(decodedString)

	return derivedFelt, nil
}

func AllEventsFilter(fromBlock, toBlock uint64, contractAddress string) (*rpc.EventFilter, error) {
	result := rpc.EventFilter{FromBlock: rpc.BlockID{Number: &fromBlock}, ToBlock: rpc.BlockID{Number: &toBlock}}

	fieldAdditiveIdentity := fp.NewElement(0)

	if contractAddress != "" {
		if contractAddress[:2] == "0x" {
			contractAddress = contractAddress[2:]
		}
		decodedAddress, decodeErr := hex.DecodeString(contractAddress)
		if decodeErr != nil {
			return &result, decodeErr
		}
		result.Address = felt.NewFelt(&fieldAdditiveIdentity)
		result.Address.SetBytes(decodedAddress)
	}

	result.Keys = [][]*felt.Felt{{}}

	return &result, nil
}

func ContractEvents(ctx context.Context, provider *rpc.Provider, contractAddress string, outChan chan<- RawEvent, hotThreshold int, hotInterval, coldInterval time.Duration, fromBlock, toBlock uint64, confirmations, batchSize int) error {
	defer func() { close(outChan) }()

	type CrawlCursor struct {
		FromBlock         uint64
		ToBlock           uint64
		ContinuationToken string
		Interval          time.Duration
		Heat              int
	}

	cursor := CrawlCursor{FromBlock: fromBlock, ToBlock: toBlock, ContinuationToken: "", Interval: hotInterval, Heat: 0}

	count := 0

	for {
		select {
		case <-ctx.Done():
			return nil
		case <-time.After(cursor.Interval):
			count++
			if cursor.ToBlock == 0 {
				currentblock, blockErr := provider.BlockNumber(ctx)
				if blockErr != nil {
					return blockErr
				}
				cursor.ToBlock = currentblock - uint64(confirmations)
			}

			if cursor.ToBlock <= cursor.FromBlock {
				// Crawl is cold, slow things down.
				cursor.Interval = coldInterval

				if toBlock == 0 {
					// If the crawl is continuous, breaks out of select, not for loop.
					// This effects a wait for the given interval.
					break
				} else {
					// If crawl is not continuous, just ends the crawl.
					return nil
				}
			}

			filter, filterErr := AllEventsFilter(cursor.FromBlock, cursor.ToBlock, contractAddress)
			if filterErr != nil {
				return filterErr
			}

			eventsInput := rpc.EventsInput{
				EventFilter:       *filter,
				ResultPageRequest: rpc.ResultPageRequest{ChunkSize: batchSize, ContinuationToken: cursor.ContinuationToken},
			}

			eventsChunk, getEventsErr := provider.Events(ctx, eventsInput)
			if getEventsErr != nil {
				return getEventsErr
			}

			for _, event := range eventsChunk.Events {
				crawledEvent := RawEvent{
					BlockNumber:     event.BlockNumber,
					BlockHash:       event.BlockHash,
					TransactionHash: event.TransactionHash,
					FromAddress:     event.FromAddress,
					PrimaryKey:      event.Keys[0],
					Keys:            event.Keys,
					Parameters:      event.Data,
				}

				outChan <- crawledEvent
			}

			if eventsChunk.ContinuationToken != "" {
				cursor.ContinuationToken = eventsChunk.ContinuationToken
				cursor.Interval = hotInterval
			} else {
				cursor.FromBlock = cursor.ToBlock + 1
				cursor.ToBlock = toBlock
				cursor.ContinuationToken = ""
				if len(eventsChunk.Events) > 0 {
					cursor.Heat++
					if cursor.Heat >= hotThreshold {
						cursor.Interval = hotInterval
					}
				} else {
					cursor.Heat = 0
					cursor.Interval = coldInterval
				}
			}
		}
	}
}

// ABI: game::Game::PlayerReward

// Game_Game_PlayerReward is the Go struct corresponding to the game::Game::PlayerReward struct.
type Game_Game_PlayerReward struct {
	AdventurerId string
	Rank         uint64
	Amount       *big.Int
	Address      string
}

// ParseGame_Game_PlayerReward parses a Game_Game_PlayerReward struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_PlayerReward struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_PlayerReward(parameters []*felt.Felt) (Game_Game_PlayerReward, int, error) {
	currentIndex := 0
	result := Game_Game_PlayerReward{}

	value0, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerId = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Rank = value1
	currentIndex += consumed

	value2, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Amount = value2
	currentIndex += consumed

	value3, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Address = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AdventurerLeveledUp

// ABI name for event
var Event_Game_Game_AdventurerLeveledUp string = "game::Game::AdventurerLeveledUp"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AdventurerLeveledUp string = "016b747f083a5bc0eb62f1465891cc9b6ce061c09e77556f949348af4e7a608a"

// Game_Game_AdventurerLeveledUp is the Go struct corresponding to the game::Game::AdventurerLeveledUp event.
type Game_Game_AdventurerLeveledUp struct {
	AdventurerState Game_Game_AdventurerState
	PreviousLevel   uint64
	NewLevel        uint64
}

// ParseGame_Game_AdventurerLeveledUp parses a Game_Game_AdventurerLeveledUp event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AdventurerLeveledUp struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AdventurerLeveledUp(parameters []*felt.Felt) (Game_Game_AdventurerLeveledUp, int, error) {
	currentIndex := 0
	result := Game_Game_AdventurerLeveledUp{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PreviousLevel = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewLevel = value2
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::PurchasedPotions

// ABI name for event
var Event_Game_Game_PurchasedPotions string = "game::Game::PurchasedPotions"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_PurchasedPotions string = "015a142c8e70a4bcecff9338b254db8b1240d0dda34c8163e098bb5b550f2ccf"

// Game_Game_PurchasedPotions is the Go struct corresponding to the game::Game::PurchasedPotions event.
type Game_Game_PurchasedPotions struct {
	AdventurerState Game_Game_AdventurerState
	Quantity        uint64
	Cost            uint64
	Health          uint64
}

// ParseGame_Game_PurchasedPotions parses a Game_Game_PurchasedPotions event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_PurchasedPotions struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_PurchasedPotions(parameters []*felt.Felt) (Game_Game_PurchasedPotions, int, error) {
	currentIndex := 0
	result := Game_Game_PurchasedPotions{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Quantity = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Cost = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Health = value3
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::RewardDistribution

// ABI name for event
var Event_Game_Game_RewardDistribution string = "game::Game::RewardDistribution"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_RewardDistribution string = "02945361ab13c4fbed57e3e6c2330d6bdd49335c8f123424a35cee08c7011747"

// Game_Game_RewardDistribution is the Go struct corresponding to the game::Game::RewardDistribution event.
type Game_Game_RewardDistribution struct {
	FirstPlace  Game_Game_PlayerReward
	SecondPlace Game_Game_PlayerReward
	ThirdPlace  Game_Game_PlayerReward
	Client      Game_Game_ClientReward
	Dao         *big.Int
}

// ParseGame_Game_RewardDistribution parses a Game_Game_RewardDistribution event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_RewardDistribution struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_RewardDistribution(parameters []*felt.Felt) (Game_Game_RewardDistribution, int, error) {
	currentIndex := 0
	result := Game_Game_RewardDistribution{}

	value0, consumed, err := ParseGame_Game_PlayerReward(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.FirstPlace = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_PlayerReward(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.SecondPlace = value1
	currentIndex += consumed

	value2, consumed, err := ParseGame_Game_PlayerReward(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ThirdPlace = value2
	currentIndex += consumed

	value3, consumed, err := ParseGame_Game_ClientReward(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Client = value3
	currentIndex += consumed

	value4, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Dao = value4
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

var EVENT_UNKNOWN = "UNKNOWN"

type ParsedEvent struct {
	Name  string
	Event interface{}
}

type PartialEvent struct {
	Name  string
	Event json.RawMessage
}

type EventParser struct {
	Event_Game_Game_StartGame_Felt               *felt.Felt
	Event_Game_Game_UpgradesAvailable_Felt       *felt.Felt
	Event_Game_Game_DiscoveredHealth_Felt        *felt.Felt
	Event_Game_Game_DiscoveredGold_Felt          *felt.Felt
	Event_Game_Game_DodgedObstacle_Felt          *felt.Felt
	Event_Game_Game_HitByObstacle_Felt           *felt.Felt
	Event_Game_Game_AmbushedByBeast_Felt         *felt.Felt
	Event_Game_Game_DiscoveredBeast_Felt         *felt.Felt
	Event_Game_Game_AttackedBeast_Felt           *felt.Felt
	Event_Game_Game_AttackedByBeast_Felt         *felt.Felt
	Event_Game_Game_SlayedBeast_Felt             *felt.Felt
	Event_Game_Game_FleeFailed_Felt              *felt.Felt
	Event_Game_Game_FleeSucceeded_Felt           *felt.Felt
	Event_Game_Game_AdventurerLeveledUp_Felt     *felt.Felt
	Event_Game_Game_PurchasedItems_Felt          *felt.Felt
	Event_Game_Game_PurchasedPotions_Felt        *felt.Felt
	Event_Game_Game_AdventurerUpgraded_Felt      *felt.Felt
	Event_Game_Game_EquippedItems_Felt           *felt.Felt
	Event_Game_Game_DroppedItems_Felt            *felt.Felt
	Event_Game_Game_ItemsLeveledUp_Felt          *felt.Felt
	Event_Game_Game_AdventurerDied_Felt          *felt.Felt
	Event_Game_Game_NewHighScore_Felt            *felt.Felt
	Event_Game_Game_IdleDeathPenalty_Felt        *felt.Felt
	Event_Game_Game_RewardDistribution_Felt      *felt.Felt
	Event_Game_Game_GameEntropyRotatedEvent_Felt *felt.Felt
	Event_Game_Game_PriceChangeEvent_Felt        *felt.Felt
}

func NewEventParser() (*EventParser, error) {
	var feltErr error
	parser := &EventParser{}

	parser.Event_Game_Game_StartGame_Felt, feltErr = FeltFromHexString(Hash_Game_Game_StartGame)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_UpgradesAvailable_Felt, feltErr = FeltFromHexString(Hash_Game_Game_UpgradesAvailable)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_DiscoveredHealth_Felt, feltErr = FeltFromHexString(Hash_Game_Game_DiscoveredHealth)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_DiscoveredGold_Felt, feltErr = FeltFromHexString(Hash_Game_Game_DiscoveredGold)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_DodgedObstacle_Felt, feltErr = FeltFromHexString(Hash_Game_Game_DodgedObstacle)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_HitByObstacle_Felt, feltErr = FeltFromHexString(Hash_Game_Game_HitByObstacle)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AmbushedByBeast_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AmbushedByBeast)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_DiscoveredBeast_Felt, feltErr = FeltFromHexString(Hash_Game_Game_DiscoveredBeast)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AttackedBeast_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AttackedBeast)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AttackedByBeast_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AttackedByBeast)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_SlayedBeast_Felt, feltErr = FeltFromHexString(Hash_Game_Game_SlayedBeast)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_FleeFailed_Felt, feltErr = FeltFromHexString(Hash_Game_Game_FleeFailed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_FleeSucceeded_Felt, feltErr = FeltFromHexString(Hash_Game_Game_FleeSucceeded)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AdventurerLeveledUp_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AdventurerLeveledUp)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_PurchasedItems_Felt, feltErr = FeltFromHexString(Hash_Game_Game_PurchasedItems)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_PurchasedPotions_Felt, feltErr = FeltFromHexString(Hash_Game_Game_PurchasedPotions)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AdventurerUpgraded_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AdventurerUpgraded)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_EquippedItems_Felt, feltErr = FeltFromHexString(Hash_Game_Game_EquippedItems)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_DroppedItems_Felt, feltErr = FeltFromHexString(Hash_Game_Game_DroppedItems)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_ItemsLeveledUp_Felt, feltErr = FeltFromHexString(Hash_Game_Game_ItemsLeveledUp)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_AdventurerDied_Felt, feltErr = FeltFromHexString(Hash_Game_Game_AdventurerDied)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_NewHighScore_Felt, feltErr = FeltFromHexString(Hash_Game_Game_NewHighScore)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_IdleDeathPenalty_Felt, feltErr = FeltFromHexString(Hash_Game_Game_IdleDeathPenalty)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_RewardDistribution_Felt, feltErr = FeltFromHexString(Hash_Game_Game_RewardDistribution)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_GameEntropyRotatedEvent_Felt, feltErr = FeltFromHexString(Hash_Game_Game_GameEntropyRotatedEvent)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Game_Game_PriceChangeEvent_Felt, feltErr = FeltFromHexString(Hash_Game_Game_PriceChangeEvent)
	if feltErr != nil {
		return parser, feltErr
	}

	return parser, nil
}

func (p *EventParser) Parse(event RawEvent) (ParsedEvent, error) {
	defaultResult := ParsedEvent{Name: EVENT_UNKNOWN, Event: event}

	if p.Event_Game_Game_StartGame_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_StartGame(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_StartGame, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_UpgradesAvailable_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_UpgradesAvailable(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_UpgradesAvailable, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_DiscoveredHealth_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_DiscoveredHealth(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_DiscoveredHealth, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_DiscoveredGold_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_DiscoveredGold(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_DiscoveredGold, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_DodgedObstacle_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_DodgedObstacle(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_DodgedObstacle, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_HitByObstacle_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_HitByObstacle(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_HitByObstacle, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AmbushedByBeast_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AmbushedByBeast(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AmbushedByBeast, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_DiscoveredBeast_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_DiscoveredBeast(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_DiscoveredBeast, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AttackedBeast_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AttackedBeast(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AttackedBeast, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AttackedByBeast_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AttackedByBeast(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AttackedByBeast, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_SlayedBeast_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_SlayedBeast(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_SlayedBeast, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_FleeFailed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_FleeFailed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_FleeFailed, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_FleeSucceeded_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_FleeSucceeded(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_FleeSucceeded, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AdventurerLeveledUp_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AdventurerLeveledUp(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AdventurerLeveledUp, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_PurchasedItems_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_PurchasedItems(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_PurchasedItems, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_PurchasedPotions_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_PurchasedPotions(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_PurchasedPotions, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AdventurerUpgraded_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AdventurerUpgraded(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AdventurerUpgraded, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_EquippedItems_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_EquippedItems(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_EquippedItems, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_DroppedItems_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_DroppedItems(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_DroppedItems, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_ItemsLeveledUp_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_ItemsLeveledUp(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_ItemsLeveledUp, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_AdventurerDied_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_AdventurerDied(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_AdventurerDied, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_NewHighScore_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_NewHighScore(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_NewHighScore, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_IdleDeathPenalty_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_IdleDeathPenalty(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_IdleDeathPenalty, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_RewardDistribution_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_RewardDistribution(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_RewardDistribution, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_GameEntropyRotatedEvent_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_GameEntropyRotatedEvent(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_GameEntropyRotatedEvent, Event: parsedEvent}, nil
	}
	if p.Event_Game_Game_PriceChangeEvent_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseGame_Game_PriceChangeEvent(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		return ParsedEvent{Name: Event_Game_Game_PriceChangeEvent, Event: parsedEvent}, nil
	}
	return defaultResult, nil
}

// ABI: combat::constants::CombatEnums::Tier

// Combat_Constants_CombatEnums_Tier is an alias for uint64
type Combat_Constants_CombatEnums_Tier = uint64

// ParseCombat_Constants_CombatEnums_Tier parses a Combat_Constants_CombatEnums_Tier from a list of felts. This function returns a tuple of:
// 1. The parsed Combat_Constants_CombatEnums_Tier
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCombat_Constants_CombatEnums_Tier(parameters []*felt.Felt) (Combat_Constants_CombatEnums_Tier, int, error) {
	if len(parameters) < 1 {
		return 0, 0, ErrIncorrectParameters
	}
	return Combat_Constants_CombatEnums_Tier(parameters[0].Uint64()), 1, nil
}

// This function returns the string representation of a Combat_Constants_CombatEnums_Tier enum. This is the enum value from the ABI definition of the enum.
func EvaluateCombat_Constants_CombatEnums_Tier(raw Combat_Constants_CombatEnums_Tier) string {
	switch raw {
	case 0:
		return "None"
	case 1:
		return "T-1"
	case 2:
		return "T0"
	case 3:
		return "T1"
	case 4:
		return "T2"
	case 5:
		return "T3"
	}
	return "UNKNOWN"
}

// ABI: game::Game::ObstacleDetails

// Game_Game_ObstacleDetails is the Go struct corresponding to the game::Game::ObstacleDetails struct.
type Game_Game_ObstacleDetails struct {
	Id                 uint64
	Level              uint64
	DamageTaken        uint64
	DamageLocation     uint64
	CriticalHit        Core_Bool
	AdventurerXpReward uint64
	ItemXpReward       uint64
}

// ParseGame_Game_ObstacleDetails parses a Game_Game_ObstacleDetails struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_ObstacleDetails struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_ObstacleDetails(parameters []*felt.Felt) (Game_Game_ObstacleDetails, int, error) {
	currentIndex := 0
	result := Game_Game_ObstacleDetails{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Level = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.DamageTaken = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.DamageLocation = value3
	currentIndex += consumed

	value4, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CriticalHit = value4
	currentIndex += consumed

	value5, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerXpReward = value5
	currentIndex += consumed

	value6, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemXpReward = value6
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::PurchasedItems

// ABI name for event
var Event_Game_Game_PurchasedItems string = "game::Game::PurchasedItems"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_PurchasedItems string = "0127e97eb6a3822aeea793175c23d1dab98c510ce54a317e530ac3891cc076fd"

// Game_Game_PurchasedItems is the Go struct corresponding to the game::Game::PurchasedItems event.
type Game_Game_PurchasedItems struct {
	AdventurerStateWithBag Game_Game_AdventurerStateWithBag
	Purchases              []Market_Market_LootWithPrice
}

// ParseGame_Game_PurchasedItems parses a Game_Game_PurchasedItems event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_PurchasedItems struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_PurchasedItems(parameters []*felt.Felt) (Game_Game_PurchasedItems, int, error) {
	currentIndex := 0
	result := Game_Game_PurchasedItems{}

	value0, consumed, err := ParseGame_Game_AdventurerStateWithBag(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerStateWithBag = value0
	currentIndex += consumed

	value1, consumed, err := ParseArray[Market_Market_LootWithPrice](ParseMarket_Market_LootWithPrice)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Purchases = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: market::market::ItemPurchase

// Market_Market_ItemPurchase is the Go struct corresponding to the market::market::ItemPurchase struct.
type Market_Market_ItemPurchase struct {
	ItemId uint64
	Equip  Core_Bool
}

// ParseMarket_Market_ItemPurchase parses a Market_Market_ItemPurchase struct from a list of felts. This function returns a tuple of:
// 1. The parsed Market_Market_ItemPurchase struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseMarket_Market_ItemPurchase(parameters []*felt.Felt) (Market_Market_ItemPurchase, int, error) {
	currentIndex := 0
	result := Market_Market_ItemPurchase{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemId = value0
	currentIndex += consumed

	value1, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Equip = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::DiscoveredGold

// ABI name for event
var Event_Game_Game_DiscoveredGold string = "game::Game::DiscoveredGold"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_DiscoveredGold string = "15b7d298d615bc8a7f835a151be6f79848d7a28abba637e6608feac27255a2"

// Game_Game_DiscoveredGold is the Go struct corresponding to the game::Game::DiscoveredGold event.
type Game_Game_DiscoveredGold struct {
	Discovery Game_Game_Discovery
}

// ParseGame_Game_DiscoveredGold parses a Game_Game_DiscoveredGold event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DiscoveredGold struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DiscoveredGold(parameters []*felt.Felt) (Game_Game_DiscoveredGold, int, error) {
	currentIndex := 0
	result := Game_Game_DiscoveredGold{}

	value0, consumed, err := ParseGame_Game_Discovery(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Discovery = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::AdventurerDied

// ABI name for event
var Event_Game_Game_AdventurerDied string = "game::Game::AdventurerDied"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AdventurerDied string = "ac0d9cf65432fd092269cbdb9901ccbffeb652bd7781b362ba30b79090fc38"

// Game_Game_AdventurerDied is the Go struct corresponding to the game::Game::AdventurerDied event.
type Game_Game_AdventurerDied struct {
	AdventurerState Game_Game_AdventurerState
	DeathDetails    Game_Game_DeathDetails
}

// ParseGame_Game_AdventurerDied parses a Game_Game_AdventurerDied event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AdventurerDied struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AdventurerDied(parameters []*felt.Felt) (Game_Game_AdventurerDied, int, error) {
	currentIndex := 0
	result := Game_Game_AdventurerDied{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_DeathDetails(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.DeathDetails = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: combat::constants::CombatEnums::Type

// Combat_Constants_CombatEnums_Type is an alias for uint64
type Combat_Constants_CombatEnums_Type = uint64

// ParseCombat_Constants_CombatEnums_Type parses a Combat_Constants_CombatEnums_Type from a list of felts. This function returns a tuple of:
// 1. The parsed Combat_Constants_CombatEnums_Type
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCombat_Constants_CombatEnums_Type(parameters []*felt.Felt) (Combat_Constants_CombatEnums_Type, int, error) {
	if len(parameters) < 1 {
		return 0, 0, ErrIncorrectParameters
	}
	return Combat_Constants_CombatEnums_Type(parameters[0].Uint64()), 1, nil
}

// This function returns the string representation of a Combat_Constants_CombatEnums_Type enum. This is the enum value from the ABI definition of the enum.
func EvaluateCombat_Constants_CombatEnums_Type(raw Combat_Constants_CombatEnums_Type) string {
	switch raw {
	case 0:
		return "None"
	case 1:
		return "Magic_or_Cloth"
	case 2:
		return "Blade_or_Hide"
	case 3:
		return "Bludgeon_or_Metal"
	case 4:
		return "Necklace"
	case 5:
		return "Ring"
	}
	return "UNKNOWN"
}

// ABI: lootitems::loot::Loot

// Lootitems_Loot_Loot is the Go struct corresponding to the lootitems::loot::Loot struct.
type Lootitems_Loot_Loot struct {
	Id       uint64
	Tier     Combat_Constants_CombatEnums_Tier
	ItemType Combat_Constants_CombatEnums_Type
	Slot     Combat_Constants_CombatEnums_Slot
}

// ParseLootitems_Loot_Loot parses a Lootitems_Loot_Loot struct from a list of felts. This function returns a tuple of:
// 1. The parsed Lootitems_Loot_Loot struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseLootitems_Loot_Loot(parameters []*felt.Felt) (Lootitems_Loot_Loot, int, error) {
	currentIndex := 0
	result := Lootitems_Loot_Loot{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value0
	currentIndex += consumed

	value1, consumed, err := ParseCombat_Constants_CombatEnums_Tier(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Tier = value1
	currentIndex += consumed

	value2, consumed, err := ParseCombat_Constants_CombatEnums_Type(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemType = value2
	currentIndex += consumed

	value3, consumed, err := ParseCombat_Constants_CombatEnums_Slot(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Slot = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: core::bool

// Core_Bool is an alias for uint64
type Core_Bool = uint64

// ParseCore_Bool parses a Core_Bool from a list of felts. This function returns a tuple of:
// 1. The parsed Core_Bool
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCore_Bool(parameters []*felt.Felt) (Core_Bool, int, error) {
	if len(parameters) < 1 {
		return 0, 0, ErrIncorrectParameters
	}
	return Core_Bool(parameters[0].Uint64()), 1, nil
}

// This function returns the string representation of a Core_Bool enum. This is the enum value from the ABI definition of the enum.
func EvaluateCore_Bool(raw Core_Bool) string {
	switch raw {
	case 0:
		return "False"
	case 1:
		return "True"
	}
	return "UNKNOWN"
}

// ABI: game_snapshot::GamesPlayedSnapshot

// GameSnapshot_GamesPlayedSnapshot is the Go struct corresponding to the game_snapshot::GamesPlayedSnapshot struct.
type GameSnapshot_GamesPlayedSnapshot struct {
	Timestamp uint64
	GameCount uint64
	Locked    uint64
}

// ParseGameSnapshot_GamesPlayedSnapshot parses a GameSnapshot_GamesPlayedSnapshot struct from a list of felts. This function returns a tuple of:
// 1. The parsed GameSnapshot_GamesPlayedSnapshot struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGameSnapshot_GamesPlayedSnapshot(parameters []*felt.Felt) (GameSnapshot_GamesPlayedSnapshot, int, error) {
	currentIndex := 0
	result := GameSnapshot_GamesPlayedSnapshot{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Timestamp = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.GameCount = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Locked = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::ObstacleEvent

// Game_Game_ObstacleEvent is the Go struct corresponding to the game::Game::ObstacleEvent struct.
type Game_Game_ObstacleEvent struct {
	AdventurerState Game_Game_AdventurerState
	ObstacleDetails Game_Game_ObstacleDetails
}

// ParseGame_Game_ObstacleEvent parses a Game_Game_ObstacleEvent struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_ObstacleEvent struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_ObstacleEvent(parameters []*felt.Felt) (Game_Game_ObstacleEvent, int, error) {
	currentIndex := 0
	result := Game_Game_ObstacleEvent{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_ObstacleDetails(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ObstacleDetails = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AmbushedByBeast

// ABI name for event
var Event_Game_Game_AmbushedByBeast string = "game::Game::AmbushedByBeast"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AmbushedByBeast string = "0317b067327eb6721c6e2e3e299b24a39b58d33771aa154e03a53f8978aa7e68"

// Game_Game_AmbushedByBeast is the Go struct corresponding to the game::Game::AmbushedByBeast event.
type Game_Game_AmbushedByBeast struct {
	AdventurerState    Game_Game_AdventurerState
	BeastBattleDetails Game_Game_BattleDetails
}

// ParseGame_Game_AmbushedByBeast parses a Game_Game_AmbushedByBeast event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AmbushedByBeast struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AmbushedByBeast(parameters []*felt.Felt) (Game_Game_AmbushedByBeast, int, error) {
	currentIndex := 0
	result := Game_Game_AmbushedByBeast{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_BattleDetails(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastBattleDetails = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::DeathDetails

// Game_Game_DeathDetails is the Go struct corresponding to the game::Game::DeathDetails struct.
type Game_Game_DeathDetails struct {
	KilledByBeast    uint64
	KilledByObstacle uint64
	CallerAddress    string
}

// ParseGame_Game_DeathDetails parses a Game_Game_DeathDetails struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DeathDetails struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DeathDetails(parameters []*felt.Felt) (Game_Game_DeathDetails, int, error) {
	currentIndex := 0
	result := Game_Game_DeathDetails{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.KilledByBeast = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.KilledByObstacle = value1
	currentIndex += consumed

	value2, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerAddress = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::FleeSucceeded

// ABI name for event
var Event_Game_Game_FleeSucceeded string = "game::Game::FleeSucceeded"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_FleeSucceeded string = "02db50d7ded17829196848c38d96ff4423f8524e315d16982d55df1b3473fca6"

// Game_Game_FleeSucceeded is the Go struct corresponding to the game::Game::FleeSucceeded event.
type Game_Game_FleeSucceeded struct {
	FleeEvent Game_Game_FleeEvent
}

// ParseGame_Game_FleeSucceeded parses a Game_Game_FleeSucceeded event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_FleeSucceeded struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_FleeSucceeded(parameters []*felt.Felt) (Game_Game_FleeSucceeded, int, error) {
	currentIndex := 0
	result := Game_Game_FleeSucceeded{}

	value0, consumed, err := ParseGame_Game_FleeEvent(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.FleeEvent = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::StartGame

// ABI name for event
var Event_Game_Game_StartGame string = "game::Game::StartGame"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_StartGame string = "023c34c070d9c09046f7f5a319c0d6d482c1f74a5926166f6ff44e5302c4b5b3"

// Game_Game_StartGame is the Go struct corresponding to the game::Game::StartGame event.
type Game_Game_StartGame struct {
	AdventurerState Game_Game_AdventurerState
	AdventurerMeta  Survivor_AdventurerMeta_AdventurerMetadata
	RevealBlock     uint64
}

// ParseGame_Game_StartGame parses a Game_Game_StartGame event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_StartGame struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_StartGame(parameters []*felt.Felt) (Game_Game_StartGame, int, error) {
	currentIndex := 0
	result := Game_Game_StartGame{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_AdventurerMeta_AdventurerMetadata(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerMeta = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.RevealBlock = value2
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::leaderboard::Leaderboard

// Survivor_Leaderboard_Leaderboard is the Go struct corresponding to the survivor::leaderboard::Leaderboard struct.
type Survivor_Leaderboard_Leaderboard struct {
	First  Survivor_Leaderboard_Score
	Second Survivor_Leaderboard_Score
	Third  Survivor_Leaderboard_Score
}

// ParseSurvivor_Leaderboard_Leaderboard parses a Survivor_Leaderboard_Leaderboard struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_Leaderboard_Leaderboard struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_Leaderboard_Leaderboard(parameters []*felt.Felt) (Survivor_Leaderboard_Leaderboard, int, error) {
	currentIndex := 0
	result := Survivor_Leaderboard_Leaderboard{}

	value0, consumed, err := ParseSurvivor_Leaderboard_Score(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.First = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_Leaderboard_Score(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Second = value1
	currentIndex += consumed

	value2, consumed, err := ParseSurvivor_Leaderboard_Score(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Third = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AdventurerState

// Game_Game_AdventurerState is the Go struct corresponding to the game::Game::AdventurerState struct.
type Game_Game_AdventurerState struct {
	Owner        string
	AdventurerId string
	Adventurer   Survivor_Adventurer_Adventurer
}

// ParseGame_Game_AdventurerState parses a Game_Game_AdventurerState struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AdventurerState struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AdventurerState(parameters []*felt.Felt) (Game_Game_AdventurerState, int, error) {
	currentIndex := 0
	result := Game_Game_AdventurerState{}

	value0, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Owner = value0
	currentIndex += consumed

	value1, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerId = value1
	currentIndex += consumed

	value2, consumed, err := ParseSurvivor_Adventurer_Adventurer(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Adventurer = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::UpgradesAvailable

// ABI name for event
var Event_Game_Game_UpgradesAvailable string = "game::Game::UpgradesAvailable"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_UpgradesAvailable string = "b497e78370ca3376efb8bd098ba912913a571e447c1b2c1ae4de95899d564f"

// Game_Game_UpgradesAvailable is the Go struct corresponding to the game::Game::UpgradesAvailable event.
type Game_Game_UpgradesAvailable struct {
	AdventurerState Game_Game_AdventurerState
	Items           []uint64
}

// ParseGame_Game_UpgradesAvailable parses a Game_Game_UpgradesAvailable event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_UpgradesAvailable struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_UpgradesAvailable(parameters []*felt.Felt) (Game_Game_UpgradesAvailable, int, error) {
	currentIndex := 0
	result := Game_Game_UpgradesAvailable{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseArray[uint64](ParseUint64)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Items = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::DroppedItems

// ABI name for event
var Event_Game_Game_DroppedItems string = "game::Game::DroppedItems"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_DroppedItems string = "035694c9186ae97e1d000975d8cc4e1eefd9393affc6655cf1706bcde28540de"

// Game_Game_DroppedItems is the Go struct corresponding to the game::Game::DroppedItems event.
type Game_Game_DroppedItems struct {
	AdventurerStateWithBag Game_Game_AdventurerStateWithBag
	ItemIds                []uint64
}

// ParseGame_Game_DroppedItems parses a Game_Game_DroppedItems event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DroppedItems struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DroppedItems(parameters []*felt.Felt) (Game_Game_DroppedItems, int, error) {
	currentIndex := 0
	result := Game_Game_DroppedItems{}

	value0, consumed, err := ParseGame_Game_AdventurerStateWithBag(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerStateWithBag = value0
	currentIndex += consumed

	value1, consumed, err := ParseArray[uint64](ParseUint64)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemIds = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::item_meta::ItemSpecials

// Survivor_ItemMeta_ItemSpecials is the Go struct corresponding to the survivor::item_meta::ItemSpecials struct.
type Survivor_ItemMeta_ItemSpecials struct {
	SpecialDash1 uint64
	Special0     uint64
	Special1     uint64
}

// ParseSurvivor_ItemMeta_ItemSpecials parses a Survivor_ItemMeta_ItemSpecials struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_ItemMeta_ItemSpecials struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_ItemMeta_ItemSpecials(parameters []*felt.Felt) (Survivor_ItemMeta_ItemSpecials, int, error) {
	currentIndex := 0
	result := Survivor_ItemMeta_ItemSpecials{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.SpecialDash1 = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Special0 = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Special1 = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::ClientReward

// Game_Game_ClientReward is the Go struct corresponding to the game::Game::ClientReward struct.
type Game_Game_ClientReward struct {
	Amount  *big.Int
	Address string
}

// ParseGame_Game_ClientReward parses a Game_Game_ClientReward struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_ClientReward struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_ClientReward(parameters []*felt.Felt) (Game_Game_ClientReward, int, error) {
	currentIndex := 0
	result := Game_Game_ClientReward{}

	value0, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Amount = value0
	currentIndex += consumed

	value1, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Address = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::SlayedBeast

// ABI name for event
var Event_Game_Game_SlayedBeast string = "game::Game::SlayedBeast"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_SlayedBeast string = "0335e768ceca00415f9ee04d58d9aebc613c76b43863445e7e33c7138184442e"

// Game_Game_SlayedBeast is the Go struct corresponding to the game::Game::SlayedBeast event.
type Game_Game_SlayedBeast struct {
	AdventurerState    Game_Game_AdventurerState
	Seed               *big.Int
	Id                 uint64
	BeastSpecs         Combat_Combat_CombatSpec
	DamageDealt        uint64
	CriticalHit        Core_Bool
	XpEarnedAdventurer uint64
	XpEarnedItems      uint64
	GoldEarned         uint64
}

// ParseGame_Game_SlayedBeast parses a Game_Game_SlayedBeast event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_SlayedBeast struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_SlayedBeast(parameters []*felt.Felt) (Game_Game_SlayedBeast, int, error) {
	currentIndex := 0
	result := Game_Game_SlayedBeast{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Seed = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value2
	currentIndex += consumed

	value3, consumed, err := ParseCombat_Combat_CombatSpec(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastSpecs = value3
	currentIndex += consumed

	value4, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.DamageDealt = value4
	currentIndex += consumed

	value5, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CriticalHit = value5
	currentIndex += consumed

	value6, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.XpEarnedAdventurer = value6
	currentIndex += consumed

	value7, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.XpEarnedItems = value7
	currentIndex += consumed

	value8, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.GoldEarned = value8
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::item_primitive::ItemPrimitive

// Survivor_ItemPrimitive_ItemPrimitive is the Go struct corresponding to the survivor::item_primitive::ItemPrimitive struct.
type Survivor_ItemPrimitive_ItemPrimitive struct {
	Id       uint64
	Xp       uint64
	Metadata uint64
}

// ParseSurvivor_ItemPrimitive_ItemPrimitive parses a Survivor_ItemPrimitive_ItemPrimitive struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_ItemPrimitive_ItemPrimitive struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters []*felt.Felt) (Survivor_ItemPrimitive_ItemPrimitive, int, error) {
	currentIndex := 0
	result := Survivor_ItemPrimitive_ItemPrimitive{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Xp = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Metadata = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: survivor::item_meta::ItemSpecialsStorage

// Survivor_ItemMeta_ItemSpecialsStorage is the Go struct corresponding to the survivor::item_meta::ItemSpecialsStorage struct.
type Survivor_ItemMeta_ItemSpecialsStorage struct {
	ItemDash1 Survivor_ItemMeta_ItemSpecials
	Item0     Survivor_ItemMeta_ItemSpecials
	Item1     Survivor_ItemMeta_ItemSpecials
	Item2     Survivor_ItemMeta_ItemSpecials
	Item3     Survivor_ItemMeta_ItemSpecials
	Item4     Survivor_ItemMeta_ItemSpecials
	Item5     Survivor_ItemMeta_ItemSpecials
	Item6     Survivor_ItemMeta_ItemSpecials
	Item7     Survivor_ItemMeta_ItemSpecials
	Item8     Survivor_ItemMeta_ItemSpecials
	Mutated   Core_Bool
}

// ParseSurvivor_ItemMeta_ItemSpecialsStorage parses a Survivor_ItemMeta_ItemSpecialsStorage struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_ItemMeta_ItemSpecialsStorage struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_ItemMeta_ItemSpecialsStorage(parameters []*felt.Felt) (Survivor_ItemMeta_ItemSpecialsStorage, int, error) {
	currentIndex := 0
	result := Survivor_ItemMeta_ItemSpecialsStorage{}

	value0, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemDash1 = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item0 = value1
	currentIndex += consumed

	value2, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item1 = value2
	currentIndex += consumed

	value3, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item2 = value3
	currentIndex += consumed

	value4, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item3 = value4
	currentIndex += consumed

	value5, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item4 = value5
	currentIndex += consumed

	value6, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item5 = value6
	currentIndex += consumed

	value7, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item6 = value7
	currentIndex += consumed

	value8, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item7 = value8
	currentIndex += consumed

	value9, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item8 = value9
	currentIndex += consumed

	value10, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Mutated = value10
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::FleeFailed

// ABI name for event
var Event_Game_Game_FleeFailed string = "game::Game::FleeFailed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_FleeFailed string = "03733166aa57fb199c903b0764828bbef285fc337dec553f0796741cec15c589"

// Game_Game_FleeFailed is the Go struct corresponding to the game::Game::FleeFailed event.
type Game_Game_FleeFailed struct {
	FleeEvent Game_Game_FleeEvent
}

// ParseGame_Game_FleeFailed parses a Game_Game_FleeFailed event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_FleeFailed struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_FleeFailed(parameters []*felt.Felt) (Game_Game_FleeFailed, int, error) {
	currentIndex := 0
	result := Game_Game_FleeFailed{}

	value0, consumed, err := ParseGame_Game_FleeEvent(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.FleeEvent = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::EquippedItems

// ABI name for event
var Event_Game_Game_EquippedItems string = "game::Game::EquippedItems"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_EquippedItems string = "02fe099b5d05c4f7cd492117d7e640f7aedc86b509965bb35de682531fb05452"

// Game_Game_EquippedItems is the Go struct corresponding to the game::Game::EquippedItems event.
type Game_Game_EquippedItems struct {
	AdventurerStateWithBag Game_Game_AdventurerStateWithBag
	EquippedItems          []uint64
	UnequippedItems        []uint64
}

// ParseGame_Game_EquippedItems parses a Game_Game_EquippedItems event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_EquippedItems struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_EquippedItems(parameters []*felt.Felt) (Game_Game_EquippedItems, int, error) {
	currentIndex := 0
	result := Game_Game_EquippedItems{}

	value0, consumed, err := ParseGame_Game_AdventurerStateWithBag(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerStateWithBag = value0
	currentIndex += consumed

	value1, consumed, err := ParseArray[uint64](ParseUint64)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.EquippedItems = value1
	currentIndex += consumed

	value2, consumed, err := ParseArray[uint64](ParseUint64)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.UnequippedItems = value2
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::GameEntropyRotatedEvent

// ABI name for event
var Event_Game_Game_GameEntropyRotatedEvent string = "game::Game::GameEntropyRotatedEvent"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_GameEntropyRotatedEvent string = "0310b5616bf40dc2dfd971ebd30938841b7f2d57fb3e6274c1a59416e1e8bc02"

// Game_Game_GameEntropyRotatedEvent is the Go struct corresponding to the game::Game::GameEntropyRotatedEvent event.
type Game_Game_GameEntropyRotatedEvent struct {
	PrevHash              string
	PrevBlockNumber       uint64
	PrevBlockTimestamp    uint64
	PrevNextRotationBlock uint64
	NewHash               string
	NewBlockNumber        uint64
	NewBlockTimestamp     uint64
	NewNextRotationBlock  uint64
	BlocksPerHour         uint64
}

// ParseGame_Game_GameEntropyRotatedEvent parses a Game_Game_GameEntropyRotatedEvent event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_GameEntropyRotatedEvent struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_GameEntropyRotatedEvent(parameters []*felt.Felt) (Game_Game_GameEntropyRotatedEvent, int, error) {
	currentIndex := 0
	result := Game_Game_GameEntropyRotatedEvent{}

	value0, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PrevHash = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PrevBlockNumber = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PrevBlockTimestamp = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PrevNextRotationBlock = value3
	currentIndex += consumed

	value4, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewHash = value4
	currentIndex += consumed

	value5, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewBlockNumber = value5
	currentIndex += consumed

	value6, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewBlockTimestamp = value6
	currentIndex += consumed

	value7, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewNextRotationBlock = value7
	currentIndex += consumed

	value8, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BlocksPerHour = value8
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: combat::combat::SpecialPowers

// Combat_Combat_SpecialPowers is the Go struct corresponding to the combat::combat::SpecialPowers struct.
type Combat_Combat_SpecialPowers struct {
	SpecialDash1 uint64
	Special0     uint64
	Special1     uint64
}

// ParseCombat_Combat_SpecialPowers parses a Combat_Combat_SpecialPowers struct from a list of felts. This function returns a tuple of:
// 1. The parsed Combat_Combat_SpecialPowers struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCombat_Combat_SpecialPowers(parameters []*felt.Felt) (Combat_Combat_SpecialPowers, int, error) {
	currentIndex := 0
	result := Combat_Combat_SpecialPowers{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.SpecialDash1 = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Special0 = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Special1 = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AttackedBeast

// ABI name for event
var Event_Game_Game_AttackedBeast string = "game::Game::AttackedBeast"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AttackedBeast string = "036637c9d2490697d67734e20c4923e77319f2cc0eb9c1f85139473b893882b0"

// Game_Game_AttackedBeast is the Go struct corresponding to the game::Game::AttackedBeast event.
type Game_Game_AttackedBeast struct {
	AdventurerState    Game_Game_AdventurerState
	BeastBattleDetails Game_Game_BattleDetails
}

// ParseGame_Game_AttackedBeast parses a Game_Game_AttackedBeast event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AttackedBeast struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AttackedBeast(parameters []*felt.Felt) (Game_Game_AttackedBeast, int, error) {
	currentIndex := 0
	result := Game_Game_AttackedBeast{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_BattleDetails(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastBattleDetails = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::leaderboard::Score

// Survivor_Leaderboard_Score is the Go struct corresponding to the survivor::leaderboard::Score struct.
type Survivor_Leaderboard_Score struct {
	AdventurerId uint64
	Xp           uint64
	Gold         uint64
}

// ParseSurvivor_Leaderboard_Score parses a Survivor_Leaderboard_Score struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_Leaderboard_Score struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_Leaderboard_Score(parameters []*felt.Felt) (Survivor_Leaderboard_Score, int, error) {
	currentIndex := 0
	result := Survivor_Leaderboard_Score{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerId = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Xp = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Gold = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::DiscoveredHealth

// ABI name for event
var Event_Game_Game_DiscoveredHealth string = "game::Game::DiscoveredHealth"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_DiscoveredHealth string = "0219a5a75d3a985c139001f09646ef572f59a6a0b5f044b163d8118c311e30ba"

// Game_Game_DiscoveredHealth is the Go struct corresponding to the game::Game::DiscoveredHealth event.
type Game_Game_DiscoveredHealth struct {
	Discovery Game_Game_Discovery
}

// ParseGame_Game_DiscoveredHealth parses a Game_Game_DiscoveredHealth event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DiscoveredHealth struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DiscoveredHealth(parameters []*felt.Felt) (Game_Game_DiscoveredHealth, int, error) {
	currentIndex := 0
	result := Game_Game_DiscoveredHealth{}

	value0, consumed, err := ParseGame_Game_Discovery(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Discovery = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::adventurer_meta::AdventurerMetadata

// Survivor_AdventurerMeta_AdventurerMetadata is the Go struct corresponding to the survivor::adventurer_meta::AdventurerMetadata struct.
type Survivor_AdventurerMeta_AdventurerMetadata struct {
	StartBlock     uint64
	StartingStats  Survivor_Stats_Stats
	Name           *big.Int
	InterfaceCamel Core_Bool
}

// ParseSurvivor_AdventurerMeta_AdventurerMetadata parses a Survivor_AdventurerMeta_AdventurerMetadata struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_AdventurerMeta_AdventurerMetadata struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_AdventurerMeta_AdventurerMetadata(parameters []*felt.Felt) (Survivor_AdventurerMeta_AdventurerMetadata, int, error) {
	currentIndex := 0
	result := Survivor_AdventurerMeta_AdventurerMetadata{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.StartBlock = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_Stats_Stats(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.StartingStats = value1
	currentIndex += consumed

	value2, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Name = value2
	currentIndex += consumed

	value3, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.InterfaceCamel = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: survivor::bag::Bag

// Survivor_Bag_Bag is the Go struct corresponding to the survivor::bag::Bag struct.
type Survivor_Bag_Bag struct {
	ItemDash1 Survivor_ItemPrimitive_ItemPrimitive
	Item0     Survivor_ItemPrimitive_ItemPrimitive
	Item1     Survivor_ItemPrimitive_ItemPrimitive
	Item2     Survivor_ItemPrimitive_ItemPrimitive
	Item3     Survivor_ItemPrimitive_ItemPrimitive
	Item4     Survivor_ItemPrimitive_ItemPrimitive
	Item5     Survivor_ItemPrimitive_ItemPrimitive
	Item6     Survivor_ItemPrimitive_ItemPrimitive
	Item7     Survivor_ItemPrimitive_ItemPrimitive
	Item8     Survivor_ItemPrimitive_ItemPrimitive
	Item9     Survivor_ItemPrimitive_ItemPrimitive
	Mutated   Core_Bool
}

// ParseSurvivor_Bag_Bag parses a Survivor_Bag_Bag struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_Bag_Bag struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_Bag_Bag(parameters []*felt.Felt) (Survivor_Bag_Bag, int, error) {
	currentIndex := 0
	result := Survivor_Bag_Bag{}

	value0, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemDash1 = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item0 = value1
	currentIndex += consumed

	value2, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item1 = value2
	currentIndex += consumed

	value3, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item2 = value3
	currentIndex += consumed

	value4, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item3 = value4
	currentIndex += consumed

	value5, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item4 = value5
	currentIndex += consumed

	value6, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item5 = value6
	currentIndex += consumed

	value7, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item6 = value7
	currentIndex += consumed

	value8, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item7 = value8
	currentIndex += consumed

	value9, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item8 = value9
	currentIndex += consumed

	value10, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item9 = value10
	currentIndex += consumed

	value11, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Mutated = value11
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::DiscoveredBeast

// ABI name for event
var Event_Game_Game_DiscoveredBeast string = "game::Game::DiscoveredBeast"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_DiscoveredBeast string = "0253a02657b86e566e59683306f5d7b2032b7814d140eeab9b85f8fcca6780fb"

// Game_Game_DiscoveredBeast is the Go struct corresponding to the game::Game::DiscoveredBeast event.
type Game_Game_DiscoveredBeast struct {
	AdventurerState Game_Game_AdventurerState
	Seed            *big.Int
	Id              uint64
	BeastSpecs      Combat_Combat_CombatSpec
}

// ParseGame_Game_DiscoveredBeast parses a Game_Game_DiscoveredBeast event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DiscoveredBeast struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DiscoveredBeast(parameters []*felt.Felt) (Game_Game_DiscoveredBeast, int, error) {
	currentIndex := 0
	result := Game_Game_DiscoveredBeast{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Seed = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value2
	currentIndex += consumed

	value3, consumed, err := ParseCombat_Combat_CombatSpec(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastSpecs = value3
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::ItemLeveledUp

// Game_Game_ItemLeveledUp is the Go struct corresponding to the game::Game::ItemLeveledUp struct.
type Game_Game_ItemLeveledUp struct {
	ItemId           uint64
	PreviousLevel    uint64
	NewLevel         uint64
	SuffixUnlocked   Core_Bool
	PrefixesUnlocked Core_Bool
	Specials         Survivor_ItemMeta_ItemSpecials
}

// ParseGame_Game_ItemLeveledUp parses a Game_Game_ItemLeveledUp struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_ItemLeveledUp struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_ItemLeveledUp(parameters []*felt.Felt) (Game_Game_ItemLeveledUp, int, error) {
	currentIndex := 0
	result := Game_Game_ItemLeveledUp{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemId = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PreviousLevel = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewLevel = value2
	currentIndex += consumed

	value3, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.SuffixUnlocked = value3
	currentIndex += consumed

	value4, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PrefixesUnlocked = value4
	currentIndex += consumed

	value5, consumed, err := ParseSurvivor_ItemMeta_ItemSpecials(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Specials = value5
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AdventurerUpgraded

// ABI name for event
var Event_Game_Game_AdventurerUpgraded string = "game::Game::AdventurerUpgraded"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AdventurerUpgraded string = "02158c8175c2574c95b9d6f44940661609d36927c128204bbc48f8854faae048"

// Game_Game_AdventurerUpgraded is the Go struct corresponding to the game::Game::AdventurerUpgraded event.
type Game_Game_AdventurerUpgraded struct {
	AdventurerStateWithBag Game_Game_AdventurerStateWithBag
	StrengthIncrease       uint64
	DexterityIncrease      uint64
	VitalityIncrease       uint64
	IntelligenceIncrease   uint64
	WisdomIncrease         uint64
	CharismaIncrease       uint64
}

// ParseGame_Game_AdventurerUpgraded parses a Game_Game_AdventurerUpgraded event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AdventurerUpgraded struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AdventurerUpgraded(parameters []*felt.Felt) (Game_Game_AdventurerUpgraded, int, error) {
	currentIndex := 0
	result := Game_Game_AdventurerUpgraded{}

	value0, consumed, err := ParseGame_Game_AdventurerStateWithBag(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerStateWithBag = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.StrengthIncrease = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.DexterityIncrease = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.VitalityIncrease = value3
	currentIndex += consumed

	value4, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.IntelligenceIncrease = value4
	currentIndex += consumed

	value5, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.WisdomIncrease = value5
	currentIndex += consumed

	value6, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CharismaIncrease = value6
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::NewHighScore

// ABI name for event
var Event_Game_Game_NewHighScore string = "game::Game::NewHighScore"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_NewHighScore string = "02326b9588750a7ce7c31809060a0123a05a60ae7eaa478d5cb01f3f797cb216"

// Game_Game_NewHighScore is the Go struct corresponding to the game::Game::NewHighScore event.
type Game_Game_NewHighScore struct {
	AdventurerState Game_Game_AdventurerState
	Rank            uint64
}

// ParseGame_Game_NewHighScore parses a Game_Game_NewHighScore event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_NewHighScore struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_NewHighScore(parameters []*felt.Felt) (Game_Game_NewHighScore, int, error) {
	currentIndex := 0
	result := Game_Game_NewHighScore{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Rank = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: combat::combat::CombatSpec

// Combat_Combat_CombatSpec is the Go struct corresponding to the combat::combat::CombatSpec struct.
type Combat_Combat_CombatSpec struct {
	Tier     Combat_Constants_CombatEnums_Tier
	ItemType Combat_Constants_CombatEnums_Type
	Level    uint64
	Specials Combat_Combat_SpecialPowers
}

// ParseCombat_Combat_CombatSpec parses a Combat_Combat_CombatSpec struct from a list of felts. This function returns a tuple of:
// 1. The parsed Combat_Combat_CombatSpec struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCombat_Combat_CombatSpec(parameters []*felt.Felt) (Combat_Combat_CombatSpec, int, error) {
	currentIndex := 0
	result := Combat_Combat_CombatSpec{}

	value0, consumed, err := ParseCombat_Constants_CombatEnums_Tier(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Tier = value0
	currentIndex += consumed

	value1, consumed, err := ParseCombat_Constants_CombatEnums_Type(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ItemType = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Level = value2
	currentIndex += consumed

	value3, consumed, err := ParseCombat_Combat_SpecialPowers(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Specials = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game_entropy::game_entropy::GameEntropy

// GameEntropy_GameEntropy_GameEntropy is the Go struct corresponding to the game_entropy::game_entropy::GameEntropy struct.
type GameEntropy_GameEntropy_GameEntropy struct {
	Hash             string
	LastUpdatedBlock uint64
	LastUpdatedTime  uint64
	NextUpdateBlock  uint64
}

// ParseGameEntropy_GameEntropy_GameEntropy parses a GameEntropy_GameEntropy_GameEntropy struct from a list of felts. This function returns a tuple of:
// 1. The parsed GameEntropy_GameEntropy_GameEntropy struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGameEntropy_GameEntropy_GameEntropy(parameters []*felt.Felt) (GameEntropy_GameEntropy_GameEntropy, int, error) {
	currentIndex := 0
	result := GameEntropy_GameEntropy_GameEntropy{}

	value0, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Hash = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.LastUpdatedBlock = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.LastUpdatedTime = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NextUpdateBlock = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::HitByObstacle

// ABI name for event
var Event_Game_Game_HitByObstacle string = "game::Game::HitByObstacle"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_HitByObstacle string = "9ebf5c9567959039f24c635b67d3a000eabf12ba43906df38b9cdbd501317a"

// Game_Game_HitByObstacle is the Go struct corresponding to the game::Game::HitByObstacle event.
type Game_Game_HitByObstacle struct {
	ObstacleEvent Game_Game_ObstacleEvent
}

// ParseGame_Game_HitByObstacle parses a Game_Game_HitByObstacle event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_HitByObstacle struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_HitByObstacle(parameters []*felt.Felt) (Game_Game_HitByObstacle, int, error) {
	currentIndex := 0
	result := Game_Game_HitByObstacle{}

	value0, consumed, err := ParseGame_Game_ObstacleEvent(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ObstacleEvent = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::ItemsLeveledUp

// ABI name for event
var Event_Game_Game_ItemsLeveledUp string = "game::Game::ItemsLeveledUp"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_ItemsLeveledUp string = "cc7cceeb77459c7412ece4747120d08750a7f9cd83b643f54926fba96521fd"

// Game_Game_ItemsLeveledUp is the Go struct corresponding to the game::Game::ItemsLeveledUp event.
type Game_Game_ItemsLeveledUp struct {
	AdventurerState Game_Game_AdventurerState
	Items           []Game_Game_ItemLeveledUp
}

// ParseGame_Game_ItemsLeveledUp parses a Game_Game_ItemsLeveledUp event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_ItemsLeveledUp struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_ItemsLeveledUp(parameters []*felt.Felt) (Game_Game_ItemsLeveledUp, int, error) {
	currentIndex := 0
	result := Game_Game_ItemsLeveledUp{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseArray[Game_Game_ItemLeveledUp](ParseGame_Game_ItemLeveledUp)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Items = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::PriceChangeEvent

// ABI name for event
var Event_Game_Game_PriceChangeEvent string = "game::Game::PriceChangeEvent"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_PriceChangeEvent string = "6a20da49efcea3fa37b370e38c87bedbda1d418a041009aa29faea92d7499a"

// Game_Game_PriceChangeEvent is the Go struct corresponding to the game::Game::PriceChangeEvent event.
type Game_Game_PriceChangeEvent struct {
	PreviousCostToPlay  *big.Int
	NewCostToPlay       *big.Int
	GlobalGamesPerDay   uint64
	SnapshotGamesPerDay uint64
	Changer             string
}

// ParseGame_Game_PriceChangeEvent parses a Game_Game_PriceChangeEvent event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_PriceChangeEvent struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_PriceChangeEvent(parameters []*felt.Felt) (Game_Game_PriceChangeEvent, int, error) {
	currentIndex := 0
	result := Game_Game_PriceChangeEvent{}

	value0, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PreviousCostToPlay = value0
	currentIndex += consumed

	value1, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.NewCostToPlay = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.GlobalGamesPerDay = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.SnapshotGamesPerDay = value3
	currentIndex += consumed

	value4, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Changer = value4
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: beasts::beast::Beast

// Beasts_Beast_Beast is the Go struct corresponding to the beasts::beast::Beast struct.
type Beasts_Beast_Beast struct {
	Id             uint64
	StartingHealth uint64
	CombatSpec     Combat_Combat_CombatSpec
}

// ParseBeasts_Beast_Beast parses a Beasts_Beast_Beast struct from a list of felts. This function returns a tuple of:
// 1. The parsed Beasts_Beast_Beast struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseBeasts_Beast_Beast(parameters []*felt.Felt) (Beasts_Beast_Beast, int, error) {
	currentIndex := 0
	result := Beasts_Beast_Beast{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.StartingHealth = value1
	currentIndex += consumed

	value2, consumed, err := ParseCombat_Combat_CombatSpec(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CombatSpec = value2
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::FleeEvent

// Game_Game_FleeEvent is the Go struct corresponding to the game::Game::FleeEvent struct.
type Game_Game_FleeEvent struct {
	AdventurerState Game_Game_AdventurerState
	Seed            *big.Int
	Id              uint64
	BeastSpecs      Combat_Combat_CombatSpec
}

// ParseGame_Game_FleeEvent parses a Game_Game_FleeEvent struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_FleeEvent struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_FleeEvent(parameters []*felt.Felt) (Game_Game_FleeEvent, int, error) {
	currentIndex := 0
	result := Game_Game_FleeEvent{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Seed = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value2
	currentIndex += consumed

	value3, consumed, err := ParseCombat_Combat_CombatSpec(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastSpecs = value3
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: market::market::LootWithPrice

// Market_Market_LootWithPrice is the Go struct corresponding to the market::market::LootWithPrice struct.
type Market_Market_LootWithPrice struct {
	Item  Lootitems_Loot_Loot
	Price uint64
}

// ParseMarket_Market_LootWithPrice parses a Market_Market_LootWithPrice struct from a list of felts. This function returns a tuple of:
// 1. The parsed Market_Market_LootWithPrice struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseMarket_Market_LootWithPrice(parameters []*felt.Felt) (Market_Market_LootWithPrice, int, error) {
	currentIndex := 0
	result := Market_Market_LootWithPrice{}

	value0, consumed, err := ParseLootitems_Loot_Loot(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Item = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Price = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::IdleDeathPenalty

// ABI name for event
var Event_Game_Game_IdleDeathPenalty string = "game::Game::IdleDeathPenalty"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_IdleDeathPenalty string = "010677066134d8347763db8e41a6bd207d841c2d6728539617c4ca9d84528319"

// Game_Game_IdleDeathPenalty is the Go struct corresponding to the game::Game::IdleDeathPenalty event.
type Game_Game_IdleDeathPenalty struct {
	AdventurerState  Game_Game_AdventurerState
	IdleBlocks       uint64
	PenaltyThreshold uint64
	Caller           string
}

// ParseGame_Game_IdleDeathPenalty parses a Game_Game_IdleDeathPenalty event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_IdleDeathPenalty struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_IdleDeathPenalty(parameters []*felt.Felt) (Game_Game_IdleDeathPenalty, int, error) {
	currentIndex := 0
	result := Game_Game_IdleDeathPenalty{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.IdleBlocks = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.PenaltyThreshold = value2
	currentIndex += consumed

	value3, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Caller = value3
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: combat::constants::CombatEnums::Slot

// Combat_Constants_CombatEnums_Slot is an alias for uint64
type Combat_Constants_CombatEnums_Slot = uint64

// ParseCombat_Constants_CombatEnums_Slot parses a Combat_Constants_CombatEnums_Slot from a list of felts. This function returns a tuple of:
// 1. The parsed Combat_Constants_CombatEnums_Slot
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseCombat_Constants_CombatEnums_Slot(parameters []*felt.Felt) (Combat_Constants_CombatEnums_Slot, int, error) {
	if len(parameters) < 1 {
		return 0, 0, ErrIncorrectParameters
	}
	return Combat_Constants_CombatEnums_Slot(parameters[0].Uint64()), 1, nil
}

// This function returns the string representation of a Combat_Constants_CombatEnums_Slot enum. This is the enum value from the ABI definition of the enum.
func EvaluateCombat_Constants_CombatEnums_Slot(raw Combat_Constants_CombatEnums_Slot) string {
	switch raw {
	case 0:
		return "None"
	case 1:
		return "Weapon"
	case 2:
		return "Chest"
	case 3:
		return "Head"
	case 4:
		return "Waist"
	case 5:
		return "Foot"
	case 6:
		return "Hand"
	case 7:
		return "Neck"
	case 8:
		return "Ring"
	}
	return "UNKNOWN"
}

// ABI: game::Game::BattleDetails

// Game_Game_BattleDetails is the Go struct corresponding to the game::Game::BattleDetails struct.
type Game_Game_BattleDetails struct {
	Seed        *big.Int
	Id          uint64
	BeastSpecs  Combat_Combat_CombatSpec
	Damage      uint64
	CriticalHit Core_Bool
	Location    uint64
}

// ParseGame_Game_BattleDetails parses a Game_Game_BattleDetails struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_BattleDetails struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_BattleDetails(parameters []*felt.Felt) (Game_Game_BattleDetails, int, error) {
	currentIndex := 0
	result := Game_Game_BattleDetails{}

	value0, consumed, err := ParseBigInt(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Seed = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Id = value1
	currentIndex += consumed

	value2, consumed, err := ParseCombat_Combat_CombatSpec(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastSpecs = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Damage = value3
	currentIndex += consumed

	value4, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CriticalHit = value4
	currentIndex += consumed

	value5, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Location = value5
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::Discovery

// Game_Game_Discovery is the Go struct corresponding to the game::Game::Discovery struct.
type Game_Game_Discovery struct {
	AdventurerState Game_Game_AdventurerState
	Amount          uint64
}

// ParseGame_Game_Discovery parses a Game_Game_Discovery struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_Discovery struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_Discovery(parameters []*felt.Felt) (Game_Game_Discovery, int, error) {
	currentIndex := 0
	result := Game_Game_Discovery{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Amount = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::AdventurerStateWithBag

// Game_Game_AdventurerStateWithBag is the Go struct corresponding to the game::Game::AdventurerStateWithBag struct.
type Game_Game_AdventurerStateWithBag struct {
	AdventurerState Game_Game_AdventurerState
	Bag             Survivor_Bag_Bag
}

// ParseGame_Game_AdventurerStateWithBag parses a Game_Game_AdventurerStateWithBag struct from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AdventurerStateWithBag struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AdventurerStateWithBag(parameters []*felt.Felt) (Game_Game_AdventurerStateWithBag, int, error) {
	currentIndex := 0
	result := Game_Game_AdventurerStateWithBag{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseSurvivor_Bag_Bag(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Bag = value1
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: game::Game::DodgedObstacle

// ABI name for event
var Event_Game_Game_DodgedObstacle string = "game::Game::DodgedObstacle"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_DodgedObstacle string = "033f51c3c3f7cce204e753c2254ff046ea56bfadfa22dee85814cbee84c9a63f"

// Game_Game_DodgedObstacle is the Go struct corresponding to the game::Game::DodgedObstacle event.
type Game_Game_DodgedObstacle struct {
	ObstacleEvent Game_Game_ObstacleEvent
}

// ParseGame_Game_DodgedObstacle parses a Game_Game_DodgedObstacle event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_DodgedObstacle struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_DodgedObstacle(parameters []*felt.Felt) (Game_Game_DodgedObstacle, int, error) {
	currentIndex := 0
	result := Game_Game_DodgedObstacle{}

	value0, consumed, err := ParseGame_Game_ObstacleEvent(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ObstacleEvent = value0
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: game::Game::AttackedByBeast

// ABI name for event
var Event_Game_Game_AttackedByBeast string = "game::Game::AttackedByBeast"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Game_Game_AttackedByBeast string = "03a441cdc9a394fdfd2ca0864d82abfec7108bb007924694b87428acfde5a1b6"

// Game_Game_AttackedByBeast is the Go struct corresponding to the game::Game::AttackedByBeast event.
type Game_Game_AttackedByBeast struct {
	AdventurerState    Game_Game_AdventurerState
	BeastBattleDetails Game_Game_BattleDetails
}

// ParseGame_Game_AttackedByBeast parses a Game_Game_AttackedByBeast event from a list of felts. This function returns a tuple of:
// 1. The parsed Game_Game_AttackedByBeast struct representing the event
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseGame_Game_AttackedByBeast(parameters []*felt.Felt) (Game_Game_AttackedByBeast, int, error) {
	currentIndex := 0
	result := Game_Game_AttackedByBeast{}

	value0, consumed, err := ParseGame_Game_AdventurerState(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.AdventurerState = value0
	currentIndex += consumed

	value1, consumed, err := ParseGame_Game_BattleDetails(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastBattleDetails = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: survivor::stats::Stats

// Survivor_Stats_Stats is the Go struct corresponding to the survivor::stats::Stats struct.
type Survivor_Stats_Stats struct {
	Strength     uint64
	Dexterity    uint64
	Vitality     uint64
	Intelligence uint64
	Wisdom       uint64
	Charisma     uint64
	Luck         uint64
}

// ParseSurvivor_Stats_Stats parses a Survivor_Stats_Stats struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_Stats_Stats struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_Stats_Stats(parameters []*felt.Felt) (Survivor_Stats_Stats, int, error) {
	currentIndex := 0
	result := Survivor_Stats_Stats{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Strength = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Dexterity = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Vitality = value2
	currentIndex += consumed

	value3, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Intelligence = value3
	currentIndex += consumed

	value4, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Wisdom = value4
	currentIndex += consumed

	value5, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Charisma = value5
	currentIndex += consumed

	value6, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Luck = value6
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: survivor::adventurer::Adventurer

// Survivor_Adventurer_Adventurer is the Go struct corresponding to the survivor::adventurer::Adventurer struct.
type Survivor_Adventurer_Adventurer struct {
	LastActionBlock     uint64
	Health              uint64
	Xp                  uint64
	Stats               Survivor_Stats_Stats
	Gold                uint64
	Weapon              Survivor_ItemPrimitive_ItemPrimitive
	Chest               Survivor_ItemPrimitive_ItemPrimitive
	Head                Survivor_ItemPrimitive_ItemPrimitive
	Waist               Survivor_ItemPrimitive_ItemPrimitive
	Foot                Survivor_ItemPrimitive_ItemPrimitive
	Hand                Survivor_ItemPrimitive_ItemPrimitive
	Neck                Survivor_ItemPrimitive_ItemPrimitive
	Ring                Survivor_ItemPrimitive_ItemPrimitive
	BeastHealth         uint64
	StatPointsAvailable uint64
	ActionsPerBlock     uint64
	Mutated             Core_Bool
}

// ParseSurvivor_Adventurer_Adventurer parses a Survivor_Adventurer_Adventurer struct from a list of felts. This function returns a tuple of:
// 1. The parsed Survivor_Adventurer_Adventurer struct
// 2. The number of field elements consumed in the parse
// 3. An error if the parse failed, nil otherwise
func ParseSurvivor_Adventurer_Adventurer(parameters []*felt.Felt) (Survivor_Adventurer_Adventurer, int, error) {
	currentIndex := 0
	result := Survivor_Adventurer_Adventurer{}

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.LastActionBlock = value0
	currentIndex += consumed

	value1, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Health = value1
	currentIndex += consumed

	value2, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Xp = value2
	currentIndex += consumed

	value3, consumed, err := ParseSurvivor_Stats_Stats(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Stats = value3
	currentIndex += consumed

	value4, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Gold = value4
	currentIndex += consumed

	value5, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Weapon = value5
	currentIndex += consumed

	value6, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Chest = value6
	currentIndex += consumed

	value7, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Head = value7
	currentIndex += consumed

	value8, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Waist = value8
	currentIndex += consumed

	value9, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Foot = value9
	currentIndex += consumed

	value10, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Hand = value10
	currentIndex += consumed

	value11, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Neck = value11
	currentIndex += consumed

	value12, consumed, err := ParseSurvivor_ItemPrimitive_ItemPrimitive(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Ring = value12
	currentIndex += consumed

	value13, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.BeastHealth = value13
	currentIndex += consumed

	value14, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.StatPointsAvailable = value14
	currentIndex += consumed

	value15, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.ActionsPerBlock = value15
	currentIndex += consumed

	value16, consumed, err := ParseCore_Bool(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Mutated = value16
	currentIndex += consumed

	return result, currentIndex, nil
}