influence.go

// This file was generated by seer: https://github.com/moonstream-to/seer.
// seer version: 0.1.1
// seer command: seer starknet generate --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: influence::contracts::crewmate::Crewmate::Approval

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_Approval string = "influence::contracts::crewmate::Crewmate::Approval"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_Approval string = "0134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff"

// Influence_Contracts_Crewmate_Crewmate_Approval is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::Approval event.
type Influence_Contracts_Crewmate_Crewmate_Approval struct {
	BlockNumber uint64

	Owner    string
	Approved string
	TokenId  *big.Int
}

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

	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.Approved = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: RemovedFromWhitelist

// ABI name for event
var Event_RemovedFromWhitelist string = "RemovedFromWhitelist"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_RemovedFromWhitelist string = "036fc4d6541c19ecd731f790455264161c67afd26b8639a17eedb1b92675f5db"

// RemovedFromWhitelist is the Go struct corresponding to the RemovedFromWhitelist event.
type RemovedFromWhitelist struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	Target     Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: cubit::f64::types::fixed::Fixed

// Cubit_F64_Types_Fixed_Fixed is the Go struct corresponding to the cubit::f64::types::fixed::Fixed struct.
type Cubit_F64_Types_Fixed_Fixed struct {
	Mag  uint64
	Sign Core_Bool
}

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::systems::seeding::seed_asteroids::SeedAsteroids::SeededAsteroid

// Influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid is the Go struct corresponding to the influence::systems::seeding::seed_asteroids::SeedAsteroids::SeededAsteroid struct.
type Influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid struct {
	AsteroidId uint64
	Name       string
}

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

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

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

	return result, currentIndex, nil
}

// ABI: AddedToWhitelist

// ABI name for event
var Event_AddedToWhitelist string = "AddedToWhitelist"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_AddedToWhitelist string = "0126e3ee57dcfe30967ad89ef340f88f22df725914885d3dd276ebac68ea2c7d"

// AddedToWhitelist is the Go struct corresponding to the AddedToWhitelist event.
type AddedToWhitelist struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	Target     Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: EmergencyDeactivated

// ABI name for event
var Event_EmergencyDeactivated string = "EmergencyDeactivated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_EmergencyDeactivated string = "0184dd408fddbdbde30821f34d25654eb5d2be8ac03e19d86fdce1c146a994e0"

// EmergencyDeactivated is the Go struct corresponding to the EmergencyDeactivated event.
type EmergencyDeactivated struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ResourceExtractionStarted

// ABI name for event
var Event_ResourceExtractionStarted string = "ResourceExtractionStarted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ResourceExtractionStarted string = "02032457432fdc3444a9d87d36c03b163de510f154164b8a6e17d305b2513e5a"

// ResourceExtractionStarted is the Go struct corresponding to the ResourceExtractionStarted event.
type ResourceExtractionStarted struct {
	BlockNumber uint64

	Deposit         Influence_Common_Types_Entity_Entity
	Resource        uint64
	Yield           uint64
	Extractor       Influence_Common_Types_Entity_Entity
	ExtractorSlot   uint64
	Destination     Influence_Common_Types_Entity_Entity
	DestinationSlot uint64
	FinishTime      uint64
	CallerCrew      Influence_Common_Types_Entity_Entity
	Caller          string
}

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: TestnetSwayClaimed

// ABI name for event
var Event_TestnetSwayClaimed string = "TestnetSwayClaimed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_TestnetSwayClaimed string = "01b7e0138e6375e2473a7b58c6f4fb01f63e4e79068ca6b7d7118a1321647ae8"

// TestnetSwayClaimed is the Go struct corresponding to the TestnetSwayClaimed event.
type TestnetSwayClaimed struct {
	BlockNumber uint64

	Amount *big.Int
	Caller string
}

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

	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.Caller = value1
	currentIndex += consumed

	return result, currentIndex + 1, nil
}

// ABI: CrewmatePurchased

// ABI name for event
var Event_CrewmatePurchased string = "CrewmatePurchased"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewmatePurchased string = "014013c248cb04a005ca138d1c858190cef324896e4b49464db60e132c9fe7f1"

// CrewmatePurchased is the Go struct corresponding to the CrewmatePurchased event.
type CrewmatePurchased struct {
	BlockNumber uint64

	Crewmate Influence_Common_Types_Entity_Entity
	Caller   string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: FoodSupplied

// ABI name for event
var Event_FoodSupplied string = "FoodSupplied"

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

// FoodSupplied is the Go struct corresponding to the FoodSupplied event.
type FoodSupplied struct {
	BlockNumber uint64

	Food       uint64
	LastFed    uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: RandomEventResolved

// ABI name for event
var Event_RandomEventResolved string = "RandomEventResolved"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_RandomEventResolved string = "0147a73243eca65757d646dc44d0829adb4e092c34ee952f9c01f3e0a89870b5"

// RandomEventResolved is the Go struct corresponding to the RandomEventResolved event.
type RandomEventResolved struct {
	BlockNumber uint64

	RandomEvent  uint64
	Choice       uint64
	ActionType   uint64
	ActionTarget Influence_Common_Types_Entity_Entity
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SurfaceScanStarted

// ABI name for event
var Event_SurfaceScanStarted string = "SurfaceScanStarted"

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

// SurfaceScanStarted is the Go struct corresponding to the SurfaceScanStarted event.
type SurfaceScanStarted struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: cubit::f128::types::fixed::Fixed

// Cubit_F128_Types_Fixed_Fixed is the Go struct corresponding to the cubit::f128::types::fixed::Fixed struct.
type Cubit_F128_Types_Fixed_Fixed struct {
	Mag  *big.Int
	Sign Core_Bool
}

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

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

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

	return result, currentIndex, nil
}

// ABI: PrepaidPolicyRemoved

// ABI name for event
var Event_PrepaidPolicyRemoved string = "PrepaidPolicyRemoved"

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

// PrepaidPolicyRemoved is the Go struct corresponding to the PrepaidPolicyRemoved event.
type PrepaidPolicyRemoved struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: MaterialProcessingStartedV1

// ABI name for event
var Event_MaterialProcessingStartedV1 string = "MaterialProcessingStartedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_MaterialProcessingStartedV1 string = "03065adaec3635cf39a14af3ca256db24878ed04ac9a67e4da02df245920e5e3"

// MaterialProcessingStartedV1 is the Go struct corresponding to the MaterialProcessingStartedV1 event.
type MaterialProcessingStartedV1 struct {
	BlockNumber uint64

	Processor       Influence_Common_Types_Entity_Entity
	ProcessorSlot   uint64
	Process         uint64
	Inputs          Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Origin          Influence_Common_Types_Entity_Entity
	OriginSlot      uint64
	Outputs         Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Destination     Influence_Common_Types_Entity_Entity
	DestinationSlot uint64
	FinishTime      uint64
	CallerCrew      Influence_Common_Types_Entity_Entity
	Caller          string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ShipDocked

// ABI name for event
var Event_ShipDocked string = "ShipDocked"

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

// ShipDocked is the Go struct corresponding to the ShipDocked event.
type ShipDocked struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	Dock       Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: influence::contracts::sway::Sway::Transfer

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_Transfer string = "influence::contracts::sway::Sway::Transfer"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Sway_Sway_Transfer string = "99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"

// Influence_Contracts_Sway_Sway_Transfer is the Go struct corresponding to the influence::contracts::sway::Sway::Transfer event.
type Influence_Contracts_Sway_Sway_Transfer struct {
	BlockNumber uint64

	From  string
	To    string
	Value *big.Int
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: BuyOrderFilled

// ABI name for event
var Event_BuyOrderFilled string = "BuyOrderFilled"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_BuyOrderFilled string = "0299d12261db430d6d61be5a1833a6080b96cdfebebbacbe89d8ff3c0cebf599"

// BuyOrderFilled is the Go struct corresponding to the BuyOrderFilled event.
type BuyOrderFilled struct {
	BlockNumber uint64

	BuyerCrew   Influence_Common_Types_Entity_Entity
	Exchange    Influence_Common_Types_Entity_Entity
	Product     uint64
	Amount      uint64
	Price       uint64
	Storage     Influence_Common_Types_Entity_Entity
	StorageSlot uint64
	Origin      Influence_Common_Types_Entity_Entity
	OriginSlot  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: EventAnnotated

// ABI name for event
var Event_EventAnnotated string = "EventAnnotated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_EventAnnotated string = "1631635a90f22aec38bc5c520de30e9f5c15aad295280c738b781b7cfea5dd"

// EventAnnotated is the Go struct corresponding to the EventAnnotated event.
type EventAnnotated struct {
	BlockNumber uint64

	TransactionHash string
	LogIndex        uint64
	ContentHash     Core_Array_Span_core_Felt252
	CallerCrew      Influence_Common_Types_Entity_Entity
	Caller          string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ConstructionFinished

// ABI name for event
var Event_ConstructionFinished string = "ConstructionFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ConstructionFinished string = "019c0dc053b7efa91a4cbade696e4472eee63b398737a2612b9621461541be46"

// ConstructionFinished is the Go struct corresponding to the ConstructionFinished event.
type ConstructionFinished struct {
	BlockNumber uint64

	Building   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewmateRecruited

// ABI name for event
var Event_CrewmateRecruited string = "CrewmateRecruited"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewmateRecruited string = "0179b7a0a16b428b78d4022a646fb56419a593ebb6694a48704f0cb49c602f56"

// CrewmateRecruited is the Go struct corresponding to the CrewmateRecruited event.
type CrewmateRecruited struct {
	BlockNumber uint64

	Crewmate   Influence_Common_Types_Entity_Entity
	Collection uint64
	Class      uint64
	Title      uint64
	Impactful  Core_Array_Span_core_Integer_U64
	Cosmetic   Core_Array_Span_core_Integer_U64
	Gender     uint64
	Body       uint64
	Face       uint64
	Hair       uint64
	HairColor  uint64
	Clothes    uint64
	Head       uint64
	Item       uint64
	Station    Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DeliveryPackagedV1

// ABI name for event
var Event_DeliveryPackagedV1 string = "DeliveryPackagedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DeliveryPackagedV1 string = "03902255f4764eb8f20a1b9cad0caa255f7ddb54811100fde3c3744e07f07519"

// DeliveryPackagedV1 is the Go struct corresponding to the DeliveryPackagedV1 event.
type DeliveryPackagedV1 struct {
	BlockNumber uint64

	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	Products   Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Dest       Influence_Common_Types_Entity_Entity
	DestSlot   uint64
	Price      uint64
	Delivery   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: BuyOrderCancelled

// ABI name for event
var Event_BuyOrderCancelled string = "BuyOrderCancelled"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_BuyOrderCancelled string = "0325d06493a9283f4f75069a95086bb73c9842b8b2e91720895ba4fbb3bb8992"

// BuyOrderCancelled is the Go struct corresponding to the BuyOrderCancelled event.
type BuyOrderCancelled struct {
	BlockNumber uint64

	BuyerCrew   Influence_Common_Types_Entity_Entity
	Exchange    Influence_Common_Types_Entity_Entity
	Product     uint64
	Amount      uint64
	Price       uint64
	Storage     Influence_Common_Types_Entity_Entity
	StorageSlot uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PublicPolicyAssigned

// ABI name for event
var Event_PublicPolicyAssigned string = "PublicPolicyAssigned"

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

// PublicPolicyAssigned is the Go struct corresponding to the PublicPolicyAssigned event.
type PublicPolicyAssigned struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: PrepareForLaunchRewardClaimed

// ABI name for event
var Event_PrepareForLaunchRewardClaimed string = "PrepareForLaunchRewardClaimed"

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

// PrepareForLaunchRewardClaimed is the Go struct corresponding to the PrepareForLaunchRewardClaimed event.
type PrepareForLaunchRewardClaimed struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crew::Crew::ApprovalForAll

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_ApprovalForAll string = "influence::contracts::crew::Crew::ApprovalForAll"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_ApprovalForAll string = "06ad9ed7b6318f1bcffefe19df9aeb40d22c36bed567e1925a5ccde0536edd"

// Influence_Contracts_Crew_Crew_ApprovalForAll is the Go struct corresponding to the influence::contracts::crew::Crew::ApprovalForAll event.
type Influence_Contracts_Crew_Crew_ApprovalForAll struct {
	BlockNumber uint64

	Owner    string
	Operator string
	Approved Core_Bool
}

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

	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.Operator = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crewmate::Crewmate::Transfer

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_Transfer string = "influence::contracts::crewmate::Crewmate::Transfer"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_Transfer string = "99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"

// Influence_Contracts_Crewmate_Crewmate_Transfer is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::Transfer event.
type Influence_Contracts_Crewmate_Crewmate_Transfer struct {
	BlockNumber uint64

	From    string
	To      string
	TokenId *big.Int
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::Transfer

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_Transfer string = "influence::contracts::ship::Ship::Transfer"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_Transfer string = "99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"

// Influence_Contracts_Ship_Ship_Transfer is the Go struct corresponding to the influence::contracts::ship::Ship::Transfer event.
type Influence_Contracts_Ship_Ship_Transfer struct {
	BlockNumber uint64

	From    string
	To      string
	TokenId *big.Int
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidAgreementExtended

// ABI name for event
var Event_PrepaidAgreementExtended string = "PrepaidAgreementExtended"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PrepaidAgreementExtended string = "01eea89a1e6b4107f4a1b3a2cb213a10967bda1938f2c8ae3926ac089f36be4c"

// PrepaidAgreementExtended is the Go struct corresponding to the PrepaidAgreementExtended event.
type PrepaidAgreementExtended struct {
	BlockNumber uint64

	Target       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Permitted    Influence_Common_Types_Entity_Entity
	Term         uint64
	Rate         uint64
	InitialTerm  uint64
	NoticePeriod uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewmatesArranged

// ABI name for event
var Event_CrewmatesArranged string = "CrewmatesArranged"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewmatesArranged string = "0381b62edeebd8bcbe9d4b935ffbe17cb8178a31cdc8017bc00a580bab62ca59"

// CrewmatesArranged is the Go struct corresponding to the CrewmatesArranged event.
type CrewmatesArranged struct {
	BlockNumber uint64

	Composition Core_Array_Span_core_Integer_U64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::starknet::eth_address::EthAddress

// Core_Starknet_EthAddress_EthAddress is the Go struct corresponding to the core::starknet::eth_address::EthAddress struct.
type Core_Starknet_EthAddress_EthAddress struct {
	Address string
}

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::dispatcher::Dispatcher::ConstantRegistered

// ABI name for event
var Event_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered string = "influence::contracts::dispatcher::Dispatcher::ConstantRegistered"

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

// Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered is the Go struct corresponding to the influence::contracts::dispatcher::Dispatcher::ConstantRegistered event.
type Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered struct {
	BlockNumber uint64

	Name  string
	Value string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::asteroid::Asteroid::BridgedToL1

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_BridgedToL1 string = "influence::contracts::asteroid::Asteroid::BridgedToL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_BridgedToL1 string = "0343404fbb463bc14499440cae988896483e039778a9ed66bfaf125d4bc364cc"

// Influence_Contracts_Asteroid_Asteroid_BridgedToL1 is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::BridgedToL1 event.
type Influence_Contracts_Asteroid_Asteroid_BridgedToL1 struct {
	BlockNumber uint64

	TokenId     *big.Int
	FromAddress string
	ToAddress   Core_Starknet_EthAddress_EthAddress
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crew::Crew::SellOrderSet

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_SellOrderSet string = "influence::contracts::crew::Crew::SellOrderSet"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_SellOrderSet string = "0258bdf4f1e869ce324d405a5c9a25758a84c1e9bb6a527ba767d16fce4fcb8a"

// Influence_Contracts_Crew_Crew_SellOrderSet is the Go struct corresponding to the influence::contracts::crew::Crew::SellOrderSet event.
type Influence_Contracts_Crew_Crew_SellOrderSet struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::dispatcher::Dispatcher::SystemRegistered

// ABI name for event
var Event_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered string = "influence::contracts::dispatcher::Dispatcher::SystemRegistered"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered string = "03437dd1689ae22432c8ea2f84eb272715fdc387f4f64c56a57c6428a97b3e90"

// Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered is the Go struct corresponding to the influence::contracts::dispatcher::Dispatcher::SystemRegistered event.
type Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered struct {
	BlockNumber uint64

	Name      string
	ClassHash string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::escrow::Escrow::ForcedWithdrawStarted

// ABI name for event
var Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted string = "influence::contracts::escrow::Escrow::ForcedWithdrawStarted"

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

// Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted is the Go struct corresponding to the influence::contracts::escrow::Escrow::ForcedWithdrawStarted event.
type Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted struct {
	BlockNumber uint64

	OrderId    string
	Caller     string
	FinishTime uint64
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DeliveryReceived

// ABI name for event
var Event_DeliveryReceived string = "DeliveryReceived"

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

// DeliveryReceived is the Go struct corresponding to the DeliveryReceived event.
type DeliveryReceived struct {
	BlockNumber uint64

	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	Products   Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Dest       Influence_Common_Types_Entity_Entity
	DestSlot   uint64
	Delivery   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

	value7, consumed, err := ParseString(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Caller = value7
	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_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered_Felt *felt.Felt
	Event_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered_Felt *felt.Felt
	Event_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered_Felt   *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_Approval_Felt               *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll_Felt         *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1_Felt          *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_BridgedToL1_Felt            *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_Transfer_Felt               *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_SellOrderSet_Felt           *felt.Felt
	Event_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled_Felt        *felt.Felt
	Event_Influence_Contracts_Crew_Crew_Approval_Felt                       *felt.Felt
	Event_Influence_Contracts_Crew_Crew_ApprovalForAll_Felt                 *felt.Felt
	Event_Influence_Contracts_Crew_Crew_BridgedFromL1_Felt                  *felt.Felt
	Event_Influence_Contracts_Crew_Crew_BridgedToL1_Felt                    *felt.Felt
	Event_Influence_Contracts_Crew_Crew_Transfer_Felt                       *felt.Felt
	Event_Influence_Contracts_Crew_Crew_SellOrderSet_Felt                   *felt.Felt
	Event_Influence_Contracts_Crew_Crew_SellOrderFilled_Felt                *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_Approval_Felt               *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll_Felt         *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1_Felt          *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_BridgedToL1_Felt            *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_Transfer_Felt               *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_SellOrderSet_Felt           *felt.Felt
	Event_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled_Felt        *felt.Felt
	Event_Influence_Contracts_Designate_Designate_Designated_Felt           *felt.Felt
	Event_Influence_Contracts_Escrow_Escrow_Deposited_Felt                  *felt.Felt
	Event_Influence_Contracts_Escrow_Escrow_Withdrawn_Felt                  *felt.Felt
	Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted_Felt      *felt.Felt
	Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished_Felt     *felt.Felt
	Event_Influence_Contracts_Ship_Ship_Approval_Felt                       *felt.Felt
	Event_Influence_Contracts_Ship_Ship_ApprovalForAll_Felt                 *felt.Felt
	Event_Influence_Contracts_Ship_Ship_BridgedFromL1_Felt                  *felt.Felt
	Event_Influence_Contracts_Ship_Ship_BridgedToL1_Felt                    *felt.Felt
	Event_Influence_Contracts_Ship_Ship_Transfer_Felt                       *felt.Felt
	Event_Influence_Contracts_Ship_Ship_SellOrderSet_Felt                   *felt.Felt
	Event_Influence_Contracts_Ship_Ship_SellOrderFilled_Felt                *felt.Felt
	Event_Influence_Contracts_Sway_Sway_Transfer_Felt                       *felt.Felt
	Event_Influence_Contracts_Sway_Sway_Approval_Felt                       *felt.Felt
	Event_Influence_Contracts_Sway_Sway_DepositHandled_Felt                 *felt.Felt
	Event_Influence_Contracts_Sway_Sway_WithdrawInitiated_Felt              *felt.Felt
	Event_Influence_Contracts_Sway_Sway_ConfirmationCreated_Felt            *felt.Felt
	Event_Influence_Contracts_Sway_Sway_ReceiptConfirmed_Felt               *felt.Felt
	Event_ContractAgreementAccepted_Felt                                    *felt.Felt
	Event_PrepaidMerkleAgreementAccepted_Felt                               *felt.Felt
	Event_PrepaidAgreementAccepted_Felt                                     *felt.Felt
	Event_PrepaidAgreementExtended_Felt                                     *felt.Felt
	Event_PrepaidAgreementCancelled_Felt                                    *felt.Felt
	Event_RemovedFromWhitelist_Felt                                         *felt.Felt
	Event_AddedToWhitelist_Felt                                             *felt.Felt
	Event_ConstructionAbandoned_Felt                                        *felt.Felt
	Event_ConstructionDeconstructed_Felt                                    *felt.Felt
	Event_ConstructionFinished_Felt                                         *felt.Felt
	Event_ConstructionPlanned_Felt                                          *felt.Felt
	Event_ConstructionStarted_Felt                                          *felt.Felt
	Event_ShipCommandeered_Felt                                             *felt.Felt
	Event_AsteroidManaged_Felt                                              *felt.Felt
	Event_LotReclaimed_Felt                                                 *felt.Felt
	Event_BuildingRepossessed_Felt                                          *felt.Felt
	Event_CrewmatesArranged_Felt                                            *felt.Felt
	Event_CrewmatesArrangedV1_Felt                                          *felt.Felt
	Event_CrewDelegated_Felt                                                *felt.Felt
	Event_CrewEjected_Felt                                                  *felt.Felt
	Event_CrewmatesExchanged_Felt                                           *felt.Felt
	Event_CrewmateRecruited_Felt                                            *felt.Felt
	Event_CrewmateRecruitedV1_Felt                                          *felt.Felt
	Event_FoodSupplied_Felt                                                 *felt.Felt
	Event_FoodSuppliedV1_Felt                                               *felt.Felt
	Event_CrewStationed_Felt                                                *felt.Felt
	Event_DeliverySent_Felt                                                 *felt.Felt
	Event_DeliveryCancelled_Felt                                            *felt.Felt
	Event_DeliveryPackaged_Felt                                             *felt.Felt
	Event_DeliveryPackagedV1_Felt                                           *felt.Felt
	Event_DeliveryReceived_Felt                                             *felt.Felt
	Event_SamplingDepositStarted_Felt                                       *felt.Felt
	Event_SamplingDepositStartedV1_Felt                                     *felt.Felt
	Event_SamplingDepositFinished_Felt                                      *felt.Felt
	Event_DepositListedForSale_Felt                                         *felt.Felt
	Event_DepositPurchased_Felt                                             *felt.Felt
	Event_DepositUnlistedForSale_Felt                                       *felt.Felt
	Event_EmergencyActivated_Felt                                           *felt.Felt
	Event_EmergencyPropellantCollected_Felt                                 *felt.Felt
	Event_EmergencyDeactivated_Felt                                         *felt.Felt
	Event_SellOrderCreated_Felt                                             *felt.Felt
	Event_SellOrderFilled_Felt                                              *felt.Felt
	Event_SellOrderCancelled_Felt                                           *felt.Felt
	Event_BuyOrderCreated_Felt                                              *felt.Felt
	Event_BuyOrderFilled_Felt                                               *felt.Felt
	Event_BuyOrderCancelled_Felt                                            *felt.Felt
	Event_ContractPolicyAssigned_Felt                                       *felt.Felt
	Event_PrepaidMerklePolicyAssigned_Felt                                  *felt.Felt
	Event_PrepaidPolicyAssigned_Felt                                        *felt.Felt
	Event_PublicPolicyAssigned_Felt                                         *felt.Felt
	Event_ContractPolicyRemoved_Felt                                        *felt.Felt
	Event_PrepaidPolicyRemoved_Felt                                         *felt.Felt
	Event_PrepaidMerklePolicyRemoved_Felt                                   *felt.Felt
	Event_PublicPolicyRemoved_Felt                                          *felt.Felt
	Event_ShipAssemblyFinished_Felt                                         *felt.Felt
	Event_ShipAssemblyStarted_Felt                                          *felt.Felt
	Event_ShipAssemblyStartedV1_Felt                                        *felt.Felt
	Event_ResourceExtractionFinished_Felt                                   *felt.Felt
	Event_ResourceExtractionStarted_Felt                                    *felt.Felt
	Event_MaterialProcessingFinished_Felt                                   *felt.Felt
	Event_MaterialProcessingStartedV1_Felt                                  *felt.Felt
	Event_RandomEventResolved_Felt                                          *felt.Felt
	Event_ArrivalRewardClaimed_Felt                                         *felt.Felt
	Event_PrepareForLaunchRewardClaimed_Felt                                *felt.Felt
	Event_TestnetSwayClaimed_Felt                                           *felt.Felt
	Event_CrewmatePurchased_Felt                                            *felt.Felt
	Event_AsteroidPurchased_Felt                                            *felt.Felt
	Event_ResourceScanFinished_Felt                                         *felt.Felt
	Event_ResourceScanStarted_Felt                                          *felt.Felt
	Event_SurfaceScanFinished_Felt                                          *felt.Felt
	Event_SurfaceScanStarted_Felt                                           *felt.Felt
	Event_NameChanged_Felt                                                  *felt.Felt
	Event_ShipDocked_Felt                                                   *felt.Felt
	Event_TransitFinished_Felt                                              *felt.Felt
	Event_TransitStarted_Felt                                               *felt.Felt
	Event_ShipUndocked_Felt                                                 *felt.Felt
	Event_EventAnnotated_Felt                                               *felt.Felt
	Event_ExchangeConfigured_Felt                                           *felt.Felt
	Event_AsteroidInitialized_Felt                                          *felt.Felt
}

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

	parser.Event_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_Approval_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_Approval)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_BridgedToL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_BridgedToL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_Transfer_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_Transfer)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_SellOrderSet_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_SellOrderSet)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_Approval_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_Approval)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_ApprovalForAll_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_ApprovalForAll)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_BridgedFromL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_BridgedFromL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_BridgedToL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_BridgedToL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_Transfer_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_Transfer)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_SellOrderSet_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_SellOrderSet)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crew_Crew_SellOrderFilled_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crew_Crew_SellOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_Approval_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_Approval)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_BridgedToL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_BridgedToL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_Transfer_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_Transfer)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_SellOrderSet_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_SellOrderSet)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Designate_Designate_Designated_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Designate_Designate_Designated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Escrow_Escrow_Deposited_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Escrow_Escrow_Deposited)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Escrow_Escrow_Withdrawn_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Escrow_Escrow_Withdrawn)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_Approval_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_Approval)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_ApprovalForAll_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_ApprovalForAll)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_BridgedFromL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_BridgedFromL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_BridgedToL1_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_BridgedToL1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_Transfer_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_Transfer)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_SellOrderSet_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_SellOrderSet)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Ship_Ship_SellOrderFilled_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Ship_Ship_SellOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_Transfer_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_Transfer)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_Approval_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_Approval)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_DepositHandled_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_DepositHandled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_WithdrawInitiated_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_WithdrawInitiated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_ConfirmationCreated_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_ConfirmationCreated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_Influence_Contracts_Sway_Sway_ReceiptConfirmed_Felt, feltErr = FeltFromHexString(Hash_Influence_Contracts_Sway_Sway_ReceiptConfirmed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ContractAgreementAccepted_Felt, feltErr = FeltFromHexString(Hash_ContractAgreementAccepted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidMerkleAgreementAccepted_Felt, feltErr = FeltFromHexString(Hash_PrepaidMerkleAgreementAccepted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidAgreementAccepted_Felt, feltErr = FeltFromHexString(Hash_PrepaidAgreementAccepted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidAgreementExtended_Felt, feltErr = FeltFromHexString(Hash_PrepaidAgreementExtended)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidAgreementCancelled_Felt, feltErr = FeltFromHexString(Hash_PrepaidAgreementCancelled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_RemovedFromWhitelist_Felt, feltErr = FeltFromHexString(Hash_RemovedFromWhitelist)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_AddedToWhitelist_Felt, feltErr = FeltFromHexString(Hash_AddedToWhitelist)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ConstructionAbandoned_Felt, feltErr = FeltFromHexString(Hash_ConstructionAbandoned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ConstructionDeconstructed_Felt, feltErr = FeltFromHexString(Hash_ConstructionDeconstructed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ConstructionFinished_Felt, feltErr = FeltFromHexString(Hash_ConstructionFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ConstructionPlanned_Felt, feltErr = FeltFromHexString(Hash_ConstructionPlanned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ConstructionStarted_Felt, feltErr = FeltFromHexString(Hash_ConstructionStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipCommandeered_Felt, feltErr = FeltFromHexString(Hash_ShipCommandeered)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_AsteroidManaged_Felt, feltErr = FeltFromHexString(Hash_AsteroidManaged)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_LotReclaimed_Felt, feltErr = FeltFromHexString(Hash_LotReclaimed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_BuildingRepossessed_Felt, feltErr = FeltFromHexString(Hash_BuildingRepossessed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmatesArranged_Felt, feltErr = FeltFromHexString(Hash_CrewmatesArranged)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmatesArrangedV1_Felt, feltErr = FeltFromHexString(Hash_CrewmatesArrangedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewDelegated_Felt, feltErr = FeltFromHexString(Hash_CrewDelegated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewEjected_Felt, feltErr = FeltFromHexString(Hash_CrewEjected)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmatesExchanged_Felt, feltErr = FeltFromHexString(Hash_CrewmatesExchanged)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmateRecruited_Felt, feltErr = FeltFromHexString(Hash_CrewmateRecruited)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmateRecruitedV1_Felt, feltErr = FeltFromHexString(Hash_CrewmateRecruitedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_FoodSupplied_Felt, feltErr = FeltFromHexString(Hash_FoodSupplied)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_FoodSuppliedV1_Felt, feltErr = FeltFromHexString(Hash_FoodSuppliedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewStationed_Felt, feltErr = FeltFromHexString(Hash_CrewStationed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DeliverySent_Felt, feltErr = FeltFromHexString(Hash_DeliverySent)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DeliveryCancelled_Felt, feltErr = FeltFromHexString(Hash_DeliveryCancelled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DeliveryPackaged_Felt, feltErr = FeltFromHexString(Hash_DeliveryPackaged)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DeliveryPackagedV1_Felt, feltErr = FeltFromHexString(Hash_DeliveryPackagedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DeliveryReceived_Felt, feltErr = FeltFromHexString(Hash_DeliveryReceived)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SamplingDepositStarted_Felt, feltErr = FeltFromHexString(Hash_SamplingDepositStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SamplingDepositStartedV1_Felt, feltErr = FeltFromHexString(Hash_SamplingDepositStartedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SamplingDepositFinished_Felt, feltErr = FeltFromHexString(Hash_SamplingDepositFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DepositListedForSale_Felt, feltErr = FeltFromHexString(Hash_DepositListedForSale)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DepositPurchased_Felt, feltErr = FeltFromHexString(Hash_DepositPurchased)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_DepositUnlistedForSale_Felt, feltErr = FeltFromHexString(Hash_DepositUnlistedForSale)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_EmergencyActivated_Felt, feltErr = FeltFromHexString(Hash_EmergencyActivated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_EmergencyPropellantCollected_Felt, feltErr = FeltFromHexString(Hash_EmergencyPropellantCollected)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_EmergencyDeactivated_Felt, feltErr = FeltFromHexString(Hash_EmergencyDeactivated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SellOrderCreated_Felt, feltErr = FeltFromHexString(Hash_SellOrderCreated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SellOrderFilled_Felt, feltErr = FeltFromHexString(Hash_SellOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SellOrderCancelled_Felt, feltErr = FeltFromHexString(Hash_SellOrderCancelled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_BuyOrderCreated_Felt, feltErr = FeltFromHexString(Hash_BuyOrderCreated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_BuyOrderFilled_Felt, feltErr = FeltFromHexString(Hash_BuyOrderFilled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_BuyOrderCancelled_Felt, feltErr = FeltFromHexString(Hash_BuyOrderCancelled)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ContractPolicyAssigned_Felt, feltErr = FeltFromHexString(Hash_ContractPolicyAssigned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidMerklePolicyAssigned_Felt, feltErr = FeltFromHexString(Hash_PrepaidMerklePolicyAssigned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidPolicyAssigned_Felt, feltErr = FeltFromHexString(Hash_PrepaidPolicyAssigned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PublicPolicyAssigned_Felt, feltErr = FeltFromHexString(Hash_PublicPolicyAssigned)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ContractPolicyRemoved_Felt, feltErr = FeltFromHexString(Hash_ContractPolicyRemoved)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidPolicyRemoved_Felt, feltErr = FeltFromHexString(Hash_PrepaidPolicyRemoved)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepaidMerklePolicyRemoved_Felt, feltErr = FeltFromHexString(Hash_PrepaidMerklePolicyRemoved)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PublicPolicyRemoved_Felt, feltErr = FeltFromHexString(Hash_PublicPolicyRemoved)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipAssemblyFinished_Felt, feltErr = FeltFromHexString(Hash_ShipAssemblyFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipAssemblyStarted_Felt, feltErr = FeltFromHexString(Hash_ShipAssemblyStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipAssemblyStartedV1_Felt, feltErr = FeltFromHexString(Hash_ShipAssemblyStartedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ResourceExtractionFinished_Felt, feltErr = FeltFromHexString(Hash_ResourceExtractionFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ResourceExtractionStarted_Felt, feltErr = FeltFromHexString(Hash_ResourceExtractionStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_MaterialProcessingFinished_Felt, feltErr = FeltFromHexString(Hash_MaterialProcessingFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_MaterialProcessingStartedV1_Felt, feltErr = FeltFromHexString(Hash_MaterialProcessingStartedV1)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_RandomEventResolved_Felt, feltErr = FeltFromHexString(Hash_RandomEventResolved)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ArrivalRewardClaimed_Felt, feltErr = FeltFromHexString(Hash_ArrivalRewardClaimed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_PrepareForLaunchRewardClaimed_Felt, feltErr = FeltFromHexString(Hash_PrepareForLaunchRewardClaimed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_TestnetSwayClaimed_Felt, feltErr = FeltFromHexString(Hash_TestnetSwayClaimed)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_CrewmatePurchased_Felt, feltErr = FeltFromHexString(Hash_CrewmatePurchased)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_AsteroidPurchased_Felt, feltErr = FeltFromHexString(Hash_AsteroidPurchased)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ResourceScanFinished_Felt, feltErr = FeltFromHexString(Hash_ResourceScanFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ResourceScanStarted_Felt, feltErr = FeltFromHexString(Hash_ResourceScanStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SurfaceScanFinished_Felt, feltErr = FeltFromHexString(Hash_SurfaceScanFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_SurfaceScanStarted_Felt, feltErr = FeltFromHexString(Hash_SurfaceScanStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_NameChanged_Felt, feltErr = FeltFromHexString(Hash_NameChanged)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipDocked_Felt, feltErr = FeltFromHexString(Hash_ShipDocked)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_TransitFinished_Felt, feltErr = FeltFromHexString(Hash_TransitFinished)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_TransitStarted_Felt, feltErr = FeltFromHexString(Hash_TransitStarted)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ShipUndocked_Felt, feltErr = FeltFromHexString(Hash_ShipUndocked)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_EventAnnotated_Felt, feltErr = FeltFromHexString(Hash_EventAnnotated)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_ExchangeConfigured_Felt, feltErr = FeltFromHexString(Hash_ExchangeConfigured)
	if feltErr != nil {
		return parser, feltErr
	}

	parser.Event_AsteroidInitialized_Felt, feltErr = FeltFromHexString(Hash_AsteroidInitialized)
	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_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Dispatcher_Dispatcher_ConstantRegistered(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Dispatcher_Dispatcher_ConstantRegistered, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Dispatcher_Dispatcher_ContractRegistered(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Dispatcher_Dispatcher_SystemRegistered(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Dispatcher_Dispatcher_SystemRegistered, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_Approval_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_Approval(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_Approval, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_ApprovalForAll(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_BridgedFromL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_BridgedToL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_BridgedToL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_BridgedToL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_Transfer_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_Transfer(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_Transfer, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_SellOrderSet_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_SellOrderSet(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_SellOrderSet, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Asteroid_Asteroid_SellOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_Approval_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_Approval(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_Approval, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_ApprovalForAll_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_ApprovalForAll(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_ApprovalForAll, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_BridgedFromL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_BridgedFromL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_BridgedFromL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_BridgedToL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_BridgedToL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_BridgedToL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_Transfer_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_Transfer(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_Transfer, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_SellOrderSet_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_SellOrderSet(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_SellOrderSet, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crew_Crew_SellOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crew_Crew_SellOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crew_Crew_SellOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_Approval_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_Approval(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_Approval, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_ApprovalForAll(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_BridgedFromL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_BridgedToL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_BridgedToL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_BridgedToL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_Transfer_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_Transfer(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_Transfer, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_SellOrderSet_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_SellOrderSet(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_SellOrderSet, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Crewmate_Crewmate_SellOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Designate_Designate_Designated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Designate_Designate_Designated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Designate_Designate_Designated, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Escrow_Escrow_Deposited_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Escrow_Escrow_Deposited(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Escrow_Escrow_Deposited, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Escrow_Escrow_Withdrawn_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Escrow_Escrow_Withdrawn(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Escrow_Escrow_Withdrawn, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Escrow_Escrow_ForcedWithdrawStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawStarted, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Escrow_Escrow_ForcedWithdrawFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_Approval_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_Approval(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_Approval, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_ApprovalForAll_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_ApprovalForAll(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_ApprovalForAll, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_BridgedFromL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_BridgedFromL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_BridgedFromL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_BridgedToL1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_BridgedToL1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_BridgedToL1, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_Transfer_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_Transfer(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_Transfer, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_SellOrderSet_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_SellOrderSet(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_SellOrderSet, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Ship_Ship_SellOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Ship_Ship_SellOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Ship_Ship_SellOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_Transfer_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_Transfer(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_Transfer, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_Approval_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_Approval(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_Approval, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_DepositHandled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_DepositHandled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_DepositHandled, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_WithdrawInitiated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_WithdrawInitiated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_WithdrawInitiated, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_ConfirmationCreated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_ConfirmationCreated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_ConfirmationCreated, Event: parsedEvent}, nil
	}
	if p.Event_Influence_Contracts_Sway_Sway_ReceiptConfirmed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseInfluence_Contracts_Sway_Sway_ReceiptConfirmed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_Influence_Contracts_Sway_Sway_ReceiptConfirmed, Event: parsedEvent}, nil
	}
	if p.Event_ContractAgreementAccepted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseContractAgreementAccepted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ContractAgreementAccepted, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidMerkleAgreementAccepted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidMerkleAgreementAccepted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidMerkleAgreementAccepted, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidAgreementAccepted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidAgreementAccepted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidAgreementAccepted, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidAgreementExtended_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidAgreementExtended(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidAgreementExtended, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidAgreementCancelled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidAgreementCancelled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidAgreementCancelled, Event: parsedEvent}, nil
	}
	if p.Event_RemovedFromWhitelist_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseRemovedFromWhitelist(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_RemovedFromWhitelist, Event: parsedEvent}, nil
	}
	if p.Event_AddedToWhitelist_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseAddedToWhitelist(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_AddedToWhitelist, Event: parsedEvent}, nil
	}
	if p.Event_ConstructionAbandoned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseConstructionAbandoned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ConstructionAbandoned, Event: parsedEvent}, nil
	}
	if p.Event_ConstructionDeconstructed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseConstructionDeconstructed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ConstructionDeconstructed, Event: parsedEvent}, nil
	}
	if p.Event_ConstructionFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseConstructionFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ConstructionFinished, Event: parsedEvent}, nil
	}
	if p.Event_ConstructionPlanned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseConstructionPlanned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ConstructionPlanned, Event: parsedEvent}, nil
	}
	if p.Event_ConstructionStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseConstructionStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ConstructionStarted, Event: parsedEvent}, nil
	}
	if p.Event_ShipCommandeered_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipCommandeered(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipCommandeered, Event: parsedEvent}, nil
	}
	if p.Event_AsteroidManaged_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseAsteroidManaged(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_AsteroidManaged, Event: parsedEvent}, nil
	}
	if p.Event_LotReclaimed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseLotReclaimed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_LotReclaimed, Event: parsedEvent}, nil
	}
	if p.Event_BuildingRepossessed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseBuildingRepossessed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_BuildingRepossessed, Event: parsedEvent}, nil
	}
	if p.Event_CrewmatesArranged_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmatesArranged(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmatesArranged, Event: parsedEvent}, nil
	}
	if p.Event_CrewmatesArrangedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmatesArrangedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmatesArrangedV1, Event: parsedEvent}, nil
	}
	if p.Event_CrewDelegated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewDelegated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewDelegated, Event: parsedEvent}, nil
	}
	if p.Event_CrewEjected_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewEjected(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewEjected, Event: parsedEvent}, nil
	}
	if p.Event_CrewmatesExchanged_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmatesExchanged(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmatesExchanged, Event: parsedEvent}, nil
	}
	if p.Event_CrewmateRecruited_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmateRecruited(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmateRecruited, Event: parsedEvent}, nil
	}
	if p.Event_CrewmateRecruitedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmateRecruitedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmateRecruitedV1, Event: parsedEvent}, nil
	}
	if p.Event_FoodSupplied_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseFoodSupplied(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_FoodSupplied, Event: parsedEvent}, nil
	}
	if p.Event_FoodSuppliedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseFoodSuppliedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_FoodSuppliedV1, Event: parsedEvent}, nil
	}
	if p.Event_CrewStationed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewStationed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewStationed, Event: parsedEvent}, nil
	}
	if p.Event_DeliverySent_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDeliverySent(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DeliverySent, Event: parsedEvent}, nil
	}
	if p.Event_DeliveryCancelled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDeliveryCancelled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DeliveryCancelled, Event: parsedEvent}, nil
	}
	if p.Event_DeliveryPackaged_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDeliveryPackaged(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DeliveryPackaged, Event: parsedEvent}, nil
	}
	if p.Event_DeliveryPackagedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDeliveryPackagedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DeliveryPackagedV1, Event: parsedEvent}, nil
	}
	if p.Event_DeliveryReceived_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDeliveryReceived(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DeliveryReceived, Event: parsedEvent}, nil
	}
	if p.Event_SamplingDepositStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSamplingDepositStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SamplingDepositStarted, Event: parsedEvent}, nil
	}
	if p.Event_SamplingDepositStartedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSamplingDepositStartedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SamplingDepositStartedV1, Event: parsedEvent}, nil
	}
	if p.Event_SamplingDepositFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSamplingDepositFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SamplingDepositFinished, Event: parsedEvent}, nil
	}
	if p.Event_DepositListedForSale_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDepositListedForSale(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DepositListedForSale, Event: parsedEvent}, nil
	}
	if p.Event_DepositPurchased_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDepositPurchased(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DepositPurchased, Event: parsedEvent}, nil
	}
	if p.Event_DepositUnlistedForSale_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseDepositUnlistedForSale(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_DepositUnlistedForSale, Event: parsedEvent}, nil
	}
	if p.Event_EmergencyActivated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseEmergencyActivated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_EmergencyActivated, Event: parsedEvent}, nil
	}
	if p.Event_EmergencyPropellantCollected_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseEmergencyPropellantCollected(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_EmergencyPropellantCollected, Event: parsedEvent}, nil
	}
	if p.Event_EmergencyDeactivated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseEmergencyDeactivated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_EmergencyDeactivated, Event: parsedEvent}, nil
	}
	if p.Event_SellOrderCreated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSellOrderCreated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SellOrderCreated, Event: parsedEvent}, nil
	}
	if p.Event_SellOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSellOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SellOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_SellOrderCancelled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSellOrderCancelled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SellOrderCancelled, Event: parsedEvent}, nil
	}
	if p.Event_BuyOrderCreated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseBuyOrderCreated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_BuyOrderCreated, Event: parsedEvent}, nil
	}
	if p.Event_BuyOrderFilled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseBuyOrderFilled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_BuyOrderFilled, Event: parsedEvent}, nil
	}
	if p.Event_BuyOrderCancelled_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseBuyOrderCancelled(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_BuyOrderCancelled, Event: parsedEvent}, nil
	}
	if p.Event_ContractPolicyAssigned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseContractPolicyAssigned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ContractPolicyAssigned, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidMerklePolicyAssigned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidMerklePolicyAssigned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidMerklePolicyAssigned, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidPolicyAssigned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidPolicyAssigned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidPolicyAssigned, Event: parsedEvent}, nil
	}
	if p.Event_PublicPolicyAssigned_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePublicPolicyAssigned(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PublicPolicyAssigned, Event: parsedEvent}, nil
	}
	if p.Event_ContractPolicyRemoved_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseContractPolicyRemoved(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ContractPolicyRemoved, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidPolicyRemoved_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidPolicyRemoved(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidPolicyRemoved, Event: parsedEvent}, nil
	}
	if p.Event_PrepaidMerklePolicyRemoved_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepaidMerklePolicyRemoved(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepaidMerklePolicyRemoved, Event: parsedEvent}, nil
	}
	if p.Event_PublicPolicyRemoved_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePublicPolicyRemoved(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PublicPolicyRemoved, Event: parsedEvent}, nil
	}
	if p.Event_ShipAssemblyFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipAssemblyFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipAssemblyFinished, Event: parsedEvent}, nil
	}
	if p.Event_ShipAssemblyStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipAssemblyStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipAssemblyStarted, Event: parsedEvent}, nil
	}
	if p.Event_ShipAssemblyStartedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipAssemblyStartedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipAssemblyStartedV1, Event: parsedEvent}, nil
	}
	if p.Event_ResourceExtractionFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseResourceExtractionFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ResourceExtractionFinished, Event: parsedEvent}, nil
	}
	if p.Event_ResourceExtractionStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseResourceExtractionStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ResourceExtractionStarted, Event: parsedEvent}, nil
	}
	if p.Event_MaterialProcessingFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseMaterialProcessingFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_MaterialProcessingFinished, Event: parsedEvent}, nil
	}
	if p.Event_MaterialProcessingStartedV1_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseMaterialProcessingStartedV1(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_MaterialProcessingStartedV1, Event: parsedEvent}, nil
	}
	if p.Event_RandomEventResolved_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseRandomEventResolved(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_RandomEventResolved, Event: parsedEvent}, nil
	}
	if p.Event_ArrivalRewardClaimed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseArrivalRewardClaimed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ArrivalRewardClaimed, Event: parsedEvent}, nil
	}
	if p.Event_PrepareForLaunchRewardClaimed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParsePrepareForLaunchRewardClaimed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_PrepareForLaunchRewardClaimed, Event: parsedEvent}, nil
	}
	if p.Event_TestnetSwayClaimed_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseTestnetSwayClaimed(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_TestnetSwayClaimed, Event: parsedEvent}, nil
	}
	if p.Event_CrewmatePurchased_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseCrewmatePurchased(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_CrewmatePurchased, Event: parsedEvent}, nil
	}
	if p.Event_AsteroidPurchased_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseAsteroidPurchased(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_AsteroidPurchased, Event: parsedEvent}, nil
	}
	if p.Event_ResourceScanFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseResourceScanFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ResourceScanFinished, Event: parsedEvent}, nil
	}
	if p.Event_ResourceScanStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseResourceScanStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ResourceScanStarted, Event: parsedEvent}, nil
	}
	if p.Event_SurfaceScanFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSurfaceScanFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SurfaceScanFinished, Event: parsedEvent}, nil
	}
	if p.Event_SurfaceScanStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseSurfaceScanStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_SurfaceScanStarted, Event: parsedEvent}, nil
	}
	if p.Event_NameChanged_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseNameChanged(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_NameChanged, Event: parsedEvent}, nil
	}
	if p.Event_ShipDocked_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipDocked(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipDocked, Event: parsedEvent}, nil
	}
	if p.Event_TransitFinished_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseTransitFinished(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_TransitFinished, Event: parsedEvent}, nil
	}
	if p.Event_TransitStarted_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseTransitStarted(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_TransitStarted, Event: parsedEvent}, nil
	}
	if p.Event_ShipUndocked_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseShipUndocked(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ShipUndocked, Event: parsedEvent}, nil
	}
	if p.Event_EventAnnotated_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseEventAnnotated(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_EventAnnotated, Event: parsedEvent}, nil
	}
	if p.Event_ExchangeConfigured_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseExchangeConfigured(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_ExchangeConfigured, Event: parsedEvent}, nil
	}
	if p.Event_AsteroidInitialized_Felt.Cmp(event.PrimaryKey) == 0 {
		parsedEvent, _, parseErr := ParseAsteroidInitialized(event.Parameters)
		if parseErr != nil {
			return defaultResult, parseErr
		}
		parsedEvent.BlockNumber = event.BlockNumber
		return ParsedEvent{Name: Event_AsteroidInitialized, Event: parsedEvent}, nil
	}
	return defaultResult, nil
}

// ABI: core::array::Span::<influence::common::types::inventory_item::InventoryItem>

// Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem is the Go struct corresponding to the core::array::Span::<influence::common::types::inventory_item::InventoryItem> struct.
type Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem struct {
	Snapshot []Influence_Common_Types_InventoryItem_InventoryItem
}

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

	value0, consumed, err := ParseArray[Influence_Common_Types_InventoryItem_InventoryItem](ParseInfluence_Common_Types_InventoryItem_InventoryItem)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: influence::systems::seeding::seed_crewmates::SeedCrewmates::SeededCrewmate

// Influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate is the Go struct corresponding to the influence::systems::seeding::seed_crewmates::SeedCrewmates::SeededCrewmate struct.
type Influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate struct {
	CrewmateId uint64
	Name       string
}

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::asteroid::Asteroid::Transfer

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_Transfer string = "influence::contracts::asteroid::Asteroid::Transfer"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_Transfer string = "99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"

// Influence_Contracts_Asteroid_Asteroid_Transfer is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::Transfer event.
type Influence_Contracts_Asteroid_Asteroid_Transfer struct {
	BlockNumber uint64

	From    string
	To      string
	TokenId *big.Int
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::Approval

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_Approval string = "influence::contracts::ship::Ship::Approval"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_Approval string = "0134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff"

// Influence_Contracts_Ship_Ship_Approval is the Go struct corresponding to the influence::contracts::ship::Ship::Approval event.
type Influence_Contracts_Ship_Ship_Approval struct {
	BlockNumber uint64

	Owner    string
	Approved string
	TokenId  *big.Int
}

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

	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.Approved = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::BridgedFromL1

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_BridgedFromL1 string = "influence::contracts::ship::Ship::BridgedFromL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_BridgedFromL1 string = "01e27a21f2a2febcf4856da1a42f353e92351fc99ab9a5feb6d4170e91296923"

// Influence_Contracts_Ship_Ship_BridgedFromL1 is the Go struct corresponding to the influence::contracts::ship::Ship::BridgedFromL1 event.
type Influence_Contracts_Ship_Ship_BridgedFromL1 struct {
	BlockNumber uint64

	TokenId   *big.Int
	ToAddress string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::SellOrderFilled

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_SellOrderFilled string = "influence::contracts::ship::Ship::SellOrderFilled"

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

// Influence_Contracts_Ship_Ship_SellOrderFilled is the Go struct corresponding to the influence::contracts::ship::Ship::SellOrderFilled event.
type Influence_Contracts_Ship_Ship_SellOrderFilled struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PublicPolicyRemoved

// ABI name for event
var Event_PublicPolicyRemoved string = "PublicPolicyRemoved"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PublicPolicyRemoved string = "031d68a59d77b4f5401197533696d0de9b7ae51e57946f1fee3df40eb6804a7f"

// PublicPolicyRemoved is the Go struct corresponding to the PublicPolicyRemoved event.
type PublicPolicyRemoved struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: influence::common::types::string::String

// Influence_Common_Types_String_String is the Go struct corresponding to the influence::common::types::string::String struct.
type Influence_Common_Types_String_String struct {
	Value *big.Int
}

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::asteroid::Asteroid::ApprovalForAll

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll string = "influence::contracts::asteroid::Asteroid::ApprovalForAll"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_ApprovalForAll string = "06ad9ed7b6318f1bcffefe19df9aeb40d22c36bed567e1925a5ccde0536edd"

// Influence_Contracts_Asteroid_Asteroid_ApprovalForAll is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::ApprovalForAll event.
type Influence_Contracts_Asteroid_Asteroid_ApprovalForAll struct {
	BlockNumber uint64

	Owner    string
	Operator string
	Approved Core_Bool
}

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

	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.Operator = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crewmate::Crewmate::BridgedToL1

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_BridgedToL1 string = "influence::contracts::crewmate::Crewmate::BridgedToL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_BridgedToL1 string = "0343404fbb463bc14499440cae988896483e039778a9ed66bfaf125d4bc364cc"

// Influence_Contracts_Crewmate_Crewmate_BridgedToL1 is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::BridgedToL1 event.
type Influence_Contracts_Crewmate_Crewmate_BridgedToL1 struct {
	BlockNumber uint64

	TokenId     *big.Int
	FromAddress string
	ToAddress   Core_Starknet_EthAddress_EthAddress
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::designate::Designate::Designated

// ABI name for event
var Event_Influence_Contracts_Designate_Designate_Designated string = "influence::contracts::designate::Designate::Designated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Designate_Designate_Designated string = "035f339dd1c3a30a45c36b115a98e6d5d4a0e18687dceec2b566a5dba2f78332"

// Influence_Contracts_Designate_Designate_Designated is the Go struct corresponding to the influence::contracts::designate::Designate::Designated event.
type Influence_Contracts_Designate_Designate_Designated struct {
	BlockNumber uint64

	Designator string
	Designee   string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidMerklePolicyRemoved

// ABI name for event
var Event_PrepaidMerklePolicyRemoved string = "PrepaidMerklePolicyRemoved"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PrepaidMerklePolicyRemoved string = "99e56201bacd45e9119b7c1ce6372670179965c7b3e612e01c449956ee0a97"

// PrepaidMerklePolicyRemoved is the Go struct corresponding to the PrepaidMerklePolicyRemoved event.
type PrepaidMerklePolicyRemoved struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ResourceExtractionFinished

// ABI name for event
var Event_ResourceExtractionFinished string = "ResourceExtractionFinished"

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

// ResourceExtractionFinished is the Go struct corresponding to the ResourceExtractionFinished event.
type ResourceExtractionFinished struct {
	BlockNumber uint64

	Extractor       Influence_Common_Types_Entity_Entity
	ExtractorSlot   uint64
	Resource        uint64
	Yield           uint64
	Destination     Influence_Common_Types_Entity_Entity
	DestinationSlot uint64
	CallerCrew      Influence_Common_Types_Entity_Entity
	Caller          string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::array::Span::<core::integer::u128>

// Core_Array_Span_core_Integer_U128 is the Go struct corresponding to the core::array::Span::<core::integer::u128> struct.
type Core_Array_Span_core_Integer_U128 struct {
	Snapshot []*big.Int
}

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

	value0, consumed, err := ParseArray[*big.Int](ParseBigInt)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: core::array::Span::<influence::systems::seeding::seed_crewmates::SeedCrewmates::SeededCrewmate>

// Core_Array_Span_influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate is the Go struct corresponding to the core::array::Span::<influence::systems::seeding::seed_crewmates::SeedCrewmates::SeededCrewmate> struct.
type Core_Array_Span_influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate struct {
	Snapshot []Influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate
}

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

	value0, consumed, err := ParseArray[Influence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate](ParseInfluence_Systems_Seeding_SeedCrewmates_SeedCrewmates_SeededCrewmate)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: influence::contracts::sway::Sway::DepositHandled

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_DepositHandled string = "influence::contracts::sway::Sway::DepositHandled"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Sway_Sway_DepositHandled string = "0374396cb322ab5ffd35ddb8627514609289d22c07d039ead5327782f61bb833"

// Influence_Contracts_Sway_Sway_DepositHandled is the Go struct corresponding to the influence::contracts::sway::Sway::DepositHandled event.
type Influence_Contracts_Sway_Sway_DepositHandled struct {
	BlockNumber uint64

	Account string
	Amount  *big.Int
	Sender  Core_Starknet_EthAddress_EthAddress
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DeliverySent

// ABI name for event
var Event_DeliverySent string = "DeliverySent"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DeliverySent string = "010de2c3a76c0f5578db9e2b41a7d26287176d2433159174cfe2fcb36e19dbaa"

// DeliverySent is the Go struct corresponding to the DeliverySent event.
type DeliverySent struct {
	BlockNumber uint64

	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	Products   Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Dest       Influence_Common_Types_Entity_Entity
	DestSlot   uint64
	Delivery   Influence_Common_Types_Entity_Entity
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ExchangeConfigured

// ABI name for event
var Event_ExchangeConfigured string = "ExchangeConfigured"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ExchangeConfigured string = "01df32a6baafac1721488087818d69d739dc9360233126d938df8d2c8bec758d"

// ExchangeConfigured is the Go struct corresponding to the ExchangeConfigured event.
type ExchangeConfigured struct {
	BlockNumber uint64

	Exchange   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::sway::Sway::ReceiptConfirmed

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_ReceiptConfirmed string = "influence::contracts::sway::Sway::ReceiptConfirmed"

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

// Influence_Contracts_Sway_Sway_ReceiptConfirmed is the Go struct corresponding to the influence::contracts::sway::Sway::ReceiptConfirmed event.
type Influence_Contracts_Sway_Sway_ReceiptConfirmed struct {
	BlockNumber uint64

	From     string
	To       string
	Value    *big.Int
	Memo     string
	Consumer string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidMerkleAgreementAccepted

// ABI name for event
var Event_PrepaidMerkleAgreementAccepted string = "PrepaidMerkleAgreementAccepted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PrepaidMerkleAgreementAccepted string = "3d1c480175f738c3c6e82109aeffb6d5e45b979dc6e454275551e6b0863d30"

// PrepaidMerkleAgreementAccepted is the Go struct corresponding to the PrepaidMerkleAgreementAccepted event.
type PrepaidMerkleAgreementAccepted struct {
	BlockNumber uint64

	Target       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Permitted    Influence_Common_Types_Entity_Entity
	Term         uint64
	Rate         uint64
	InitialTerm  uint64
	NoticePeriod uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidAgreementAccepted

// ABI name for event
var Event_PrepaidAgreementAccepted string = "PrepaidAgreementAccepted"

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

// PrepaidAgreementAccepted is the Go struct corresponding to the PrepaidAgreementAccepted event.
type PrepaidAgreementAccepted struct {
	BlockNumber uint64

	Target       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Permitted    Influence_Common_Types_Entity_Entity
	Term         uint64
	Rate         uint64
	InitialTerm  uint64
	NoticePeriod uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: FoodSuppliedV1

// ABI name for event
var Event_FoodSuppliedV1 string = "FoodSuppliedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_FoodSuppliedV1 string = "644798dd8cb708a1b6c59a8272338d4b75f52ba46504bf2d85108b6d4800fd"

// FoodSuppliedV1 is the Go struct corresponding to the FoodSuppliedV1 event.
type FoodSuppliedV1 struct {
	BlockNumber uint64

	Food       uint64
	LastFed    uint64
	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewStationed

// ABI name for event
var Event_CrewStationed string = "CrewStationed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewStationed string = "020291aa913b873ebd27f3feb72066d5dd7129467c032208b1064d06002f2aa2"

// CrewStationed is the Go struct corresponding to the CrewStationed event.
type CrewStationed struct {
	BlockNumber uint64

	Station    Influence_Common_Types_Entity_Entity
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ShipAssemblyFinished

// ABI name for event
var Event_ShipAssemblyFinished string = "ShipAssemblyFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ShipAssemblyFinished string = "034ebc82341a3486c93a0e714f6c7f2b4127e01685c4034ab9053fa2350e84b3"

// ShipAssemblyFinished is the Go struct corresponding to the ShipAssemblyFinished event.
type ShipAssemblyFinished struct {
	BlockNumber uint64

	Ship        Influence_Common_Types_Entity_Entity
	DryDock     Influence_Common_Types_Entity_Entity
	DryDockSlot uint64
	Destination Influence_Common_Types_Entity_Entity
	FinishTime  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::systems::orders::fill_buy::Withdrawal

// Influence_Systems_Orders_FillBuy_Withdrawal is the Go struct corresponding to the influence::systems::orders::fill_buy::Withdrawal struct.
type Influence_Systems_Orders_FillBuy_Withdrawal struct {
	Recipient string
	Amount    *big.Int
}

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::escrow::Escrow::Withdrawn

// ABI name for event
var Event_Influence_Contracts_Escrow_Escrow_Withdrawn string = "influence::contracts::escrow::Escrow::Withdrawn"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Escrow_Escrow_Withdrawn string = "036a4d15ab9e146faab90d4abc1c0cad17c4ded24551c781ba100392b5a70248"

// Influence_Contracts_Escrow_Escrow_Withdrawn is the Go struct corresponding to the influence::contracts::escrow::Escrow::Withdrawn event.
type Influence_Contracts_Escrow_Escrow_Withdrawn struct {
	BlockNumber uint64

	OrderId      string
	Caller       string
	Withdrawals  Core_Array_Span_influence_Contracts_Escrow_Withdrawal
	WithdrawHook Influence_Contracts_Escrow_Hook
}

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidMerklePolicyAssigned

// ABI name for event
var Event_PrepaidMerklePolicyAssigned string = "PrepaidMerklePolicyAssigned"

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

// PrepaidMerklePolicyAssigned is the Go struct corresponding to the PrepaidMerklePolicyAssigned event.
type PrepaidMerklePolicyAssigned struct {
	BlockNumber uint64

	Entity       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Rate         uint64
	InitialTerm  uint64
	NoticePeriod uint64
	MerkleRoot   string
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::array::Span::<influence::systems::orders::fill_buy::Withdrawal>

// Core_Array_Span_influence_Systems_Orders_FillBuy_Withdrawal is the Go struct corresponding to the core::array::Span::<influence::systems::orders::fill_buy::Withdrawal> struct.
type Core_Array_Span_influence_Systems_Orders_FillBuy_Withdrawal struct {
	Snapshot []Influence_Systems_Orders_FillBuy_Withdrawal
}

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

	value0, consumed, err := ParseArray[Influence_Systems_Orders_FillBuy_Withdrawal](ParseInfluence_Systems_Orders_FillBuy_Withdrawal)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: ConstructionDeconstructed

// ABI name for event
var Event_ConstructionDeconstructed string = "ConstructionDeconstructed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ConstructionDeconstructed string = "02618c38a19a282510a1c6e94f6ef6b78bd0108e5a5259918209a115173b08c7"

// ConstructionDeconstructed is the Go struct corresponding to the ConstructionDeconstructed event.
type ConstructionDeconstructed struct {
	BlockNumber uint64

	Building   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: BuildingRepossessed

// ABI name for event
var Event_BuildingRepossessed string = "BuildingRepossessed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_BuildingRepossessed string = "01085a37d58e6a75db0dadc9bb9e6707ed9c5630aec61fdcdcd832decec751c0"

// BuildingRepossessed is the Go struct corresponding to the BuildingRepossessed event.
type BuildingRepossessed struct {
	BlockNumber uint64

	Building   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DepositPurchased

// ABI name for event
var Event_DepositPurchased string = "DepositPurchased"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DepositPurchased string = "447cf85dea872f585c555b8dd39143c520052951a0386ffd13bffefbcde01e"

// DepositPurchased is the Go struct corresponding to the DepositPurchased event.
type DepositPurchased struct {
	BlockNumber uint64

	Deposit    Influence_Common_Types_Entity_Entity
	Price      uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: AsteroidInitialized

// ABI name for event
var Event_AsteroidInitialized string = "AsteroidInitialized"

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

// AsteroidInitialized is the Go struct corresponding to the AsteroidInitialized event.
type AsteroidInitialized struct {
	BlockNumber uint64

	Asteroid Influence_Common_Types_Entity_Entity
}

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::array::Span::<core::felt252>

// Core_Array_Span_core_Felt252 is the Go struct corresponding to the core::array::Span::<core::felt252> struct.
type Core_Array_Span_core_Felt252 struct {
	Snapshot []string
}

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::crew::Crew::SellOrderFilled

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_SellOrderFilled string = "influence::contracts::crew::Crew::SellOrderFilled"

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

// Influence_Contracts_Crew_Crew_SellOrderFilled is the Go struct corresponding to the influence::contracts::crew::Crew::SellOrderFilled event.
type Influence_Contracts_Crew_Crew_SellOrderFilled struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::escrow::Escrow::Deposited

// ABI name for event
var Event_Influence_Contracts_Escrow_Escrow_Deposited string = "influence::contracts::escrow::Escrow::Deposited"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Escrow_Escrow_Deposited string = "69105484e3b5f553164aa6de1f67321ea2757275a5e614365c90b9ed0a5e9b"

// Influence_Contracts_Escrow_Escrow_Deposited is the Go struct corresponding to the influence::contracts::escrow::Escrow::Deposited event.
type Influence_Contracts_Escrow_Escrow_Deposited struct {
	BlockNumber uint64

	OrderId      string
	Caller       string
	Token        string
	Amount       *big.Int
	DepositHook  Influence_Contracts_Escrow_Hook
	WithdrawHook Influence_Contracts_Escrow_Hook
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::sway::Sway::Approval

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_Approval string = "influence::contracts::sway::Sway::Approval"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Sway_Sway_Approval string = "0134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff"

// Influence_Contracts_Sway_Sway_Approval is the Go struct corresponding to the influence::contracts::sway::Sway::Approval event.
type Influence_Contracts_Sway_Sway_Approval struct {
	BlockNumber uint64

	Owner   string
	Spender string
	Value   *big.Int
}

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

	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.Spender = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: ContractAgreementAccepted

// ABI name for event
var Event_ContractAgreementAccepted string = "ContractAgreementAccepted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ContractAgreementAccepted string = "01928520880bbb1833193302f1fcae60ad75dcba8de37daaf33db4f5f3d1626c"

// ContractAgreementAccepted is the Go struct corresponding to the ContractAgreementAccepted event.
type ContractAgreementAccepted struct {
	BlockNumber uint64

	Target     Influence_Common_Types_Entity_Entity
	Permission uint64
	Permitted  Influence_Common_Types_Entity_Entity
	Contract   string
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SamplingDepositStarted

// ABI name for event
var Event_SamplingDepositStarted string = "SamplingDepositStarted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_SamplingDepositStarted string = "03465ead883d785144cbe73b9ac25cd478a549a8f7220f413873688fab63f2ce"

// SamplingDepositStarted is the Go struct corresponding to the SamplingDepositStarted event.
type SamplingDepositStarted struct {
	BlockNumber uint64

	Deposit    Influence_Common_Types_Entity_Entity
	Lot        Influence_Common_Types_Entity_Entity
	Resource   uint64
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: EmergencyActivated

// ABI name for event
var Event_EmergencyActivated string = "EmergencyActivated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_EmergencyActivated string = "037b829b79d48837b154da2ff68a2a3de0a03a70acec6af2d1a91f36f1666d4f"

// EmergencyActivated is the Go struct corresponding to the EmergencyActivated event.
type EmergencyActivated struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ResourceScanStarted

// ABI name for event
var Event_ResourceScanStarted string = "ResourceScanStarted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ResourceScanStarted string = "019afa5d12dfbf6b506badd26eaf5586b429ccb5e82ba24c8d46ca750f1812f6"

// ResourceScanStarted is the Go struct corresponding to the ResourceScanStarted event.
type ResourceScanStarted struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: influence::contracts::escrow::Withdrawal

// Influence_Contracts_Escrow_Withdrawal is the Go struct corresponding to the influence::contracts::escrow::Withdrawal struct.
type Influence_Contracts_Escrow_Withdrawal struct {
	Recipient string
	Amount    *big.Int
}

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::common::types::context::Context

// Influence_Common_Types_Context_Context is the Go struct corresponding to the influence::common::types::context::Context struct.
type Influence_Common_Types_Context_Context struct {
	Caller        string
	Now           uint64
	PaymentTo     string
	PaymentAmount uint64
}

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

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

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::asteroid::Asteroid::Approval

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_Approval string = "influence::contracts::asteroid::Asteroid::Approval"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_Approval string = "0134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff"

// Influence_Contracts_Asteroid_Asteroid_Approval is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::Approval event.
type Influence_Contracts_Asteroid_Asteroid_Approval struct {
	BlockNumber uint64

	Owner    string
	Approved string
	TokenId  *big.Int
}

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

	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.Approved = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::sway::Sway::WithdrawInitiated

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_WithdrawInitiated string = "influence::contracts::sway::Sway::WithdrawInitiated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Sway_Sway_WithdrawInitiated string = "0282f521c69b2bc696552b9e141009d3c84f2df75e2e7b7716644d31e60f23b1"

// Influence_Contracts_Sway_Sway_WithdrawInitiated is the Go struct corresponding to the influence::contracts::sway::Sway::WithdrawInitiated event.
type Influence_Contracts_Sway_Sway_WithdrawInitiated struct {
	BlockNumber uint64

	L1Recipient   Core_Starknet_EthAddress_EthAddress
	Amount        *big.Int
	CallerAddress string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DepositListedForSale

// ABI name for event
var Event_DepositListedForSale string = "DepositListedForSale"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DepositListedForSale string = "0117b64b3d3507afa9a065b0c4d78690b6daacbca1869898273fddede8f757b4"

// DepositListedForSale is the Go struct corresponding to the DepositListedForSale event.
type DepositListedForSale struct {
	BlockNumber uint64

	Deposit    Influence_Common_Types_Entity_Entity
	Price      uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: SellOrderCancelled

// ABI name for event
var Event_SellOrderCancelled string = "SellOrderCancelled"

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

// SellOrderCancelled is the Go struct corresponding to the SellOrderCancelled event.
type SellOrderCancelled struct {
	BlockNumber uint64

	SellerCrew  Influence_Common_Types_Entity_Entity
	Exchange    Influence_Common_Types_Entity_Entity
	Product     uint64
	Price       uint64
	Storage     Influence_Common_Types_Entity_Entity
	StorageSlot uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: MaterialProcessingFinished

// ABI name for event
var Event_MaterialProcessingFinished string = "MaterialProcessingFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_MaterialProcessingFinished string = "17d3031632aeed96ab9d68226d6439ef5fdc0bb7f8086a7cc6a54207da53e4"

// MaterialProcessingFinished is the Go struct corresponding to the MaterialProcessingFinished event.
type MaterialProcessingFinished struct {
	BlockNumber uint64

	Processor     Influence_Common_Types_Entity_Entity
	ProcessorSlot uint64
	CallerCrew    Influence_Common_Types_Entity_Entity
	Caller        string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: 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: influence::contracts::crewmate::Crewmate::SellOrderSet

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_SellOrderSet string = "influence::contracts::crewmate::Crewmate::SellOrderSet"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_SellOrderSet string = "0258bdf4f1e869ce324d405a5c9a25758a84c1e9bb6a527ba767d16fce4fcb8a"

// Influence_Contracts_Crewmate_Crewmate_SellOrderSet is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::SellOrderSet event.
type Influence_Contracts_Crewmate_Crewmate_SellOrderSet struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crewmate::Crewmate::SellOrderFilled

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_SellOrderFilled string = "influence::contracts::crewmate::Crewmate::SellOrderFilled"

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

// Influence_Contracts_Crewmate_Crewmate_SellOrderFilled is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::SellOrderFilled event.
type Influence_Contracts_Crewmate_Crewmate_SellOrderFilled struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ConstructionStarted

// ABI name for event
var Event_ConstructionStarted string = "ConstructionStarted"

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

// ConstructionStarted is the Go struct corresponding to the ConstructionStarted event.
type ConstructionStarted struct {
	BlockNumber uint64

	Building   Influence_Common_Types_Entity_Entity
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: DepositUnlistedForSale

// ABI name for event
var Event_DepositUnlistedForSale string = "DepositUnlistedForSale"

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

// DepositUnlistedForSale is the Go struct corresponding to the DepositUnlistedForSale event.
type DepositUnlistedForSale struct {
	BlockNumber uint64

	Deposit    Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidPolicyAssigned

// ABI name for event
var Event_PrepaidPolicyAssigned string = "PrepaidPolicyAssigned"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PrepaidPolicyAssigned string = "0339aea03da488f765f428ab59172a1c421119eadbf75eaaf8393b802e5c2dfe"

// PrepaidPolicyAssigned is the Go struct corresponding to the PrepaidPolicyAssigned event.
type PrepaidPolicyAssigned struct {
	BlockNumber uint64

	Entity       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Rate         uint64
	InitialTerm  uint64
	NoticePeriod uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ArrivalRewardClaimed

// ABI name for event
var Event_ArrivalRewardClaimed string = "ArrivalRewardClaimed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ArrivalRewardClaimed string = "018012f7c5562b2f783f4b7b6e34d14970cd5355325a8ed3f2882b8928614cc7"

// ArrivalRewardClaimed is the Go struct corresponding to the ArrivalRewardClaimed event.
type ArrivalRewardClaimed struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::common::types::inventory_item::InventoryItem

// Influence_Common_Types_InventoryItem_InventoryItem is the Go struct corresponding to the influence::common::types::inventory_item::InventoryItem struct.
type Influence_Common_Types_InventoryItem_InventoryItem struct {
	Product uint64
	Amount  uint64
}

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

	value0, consumed, err := ParseUint64(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Product = 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: core::array::Span::<influence::systems::seeding::seed_asteroids::SeedAsteroids::SeededAsteroid>

// Core_Array_Span_influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid is the Go struct corresponding to the core::array::Span::<influence::systems::seeding::seed_asteroids::SeedAsteroids::SeededAsteroid> struct.
type Core_Array_Span_influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid struct {
	Snapshot []Influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid
}

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

	value0, consumed, err := ParseArray[Influence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid](ParseInfluence_Systems_Seeding_SeedAsteroids_SeedAsteroids_SeededAsteroid)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: influence::contracts::crewmate::Crewmate::BridgedFromL1

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1 string = "influence::contracts::crewmate::Crewmate::BridgedFromL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_BridgedFromL1 string = "01e27a21f2a2febcf4856da1a42f353e92351fc99ab9a5feb6d4170e91296923"

// Influence_Contracts_Crewmate_Crewmate_BridgedFromL1 is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::BridgedFromL1 event.
type Influence_Contracts_Crewmate_Crewmate_BridgedFromL1 struct {
	BlockNumber uint64

	TokenId   *big.Int
	ToAddress string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: PrepaidAgreementCancelled

// ABI name for event
var Event_PrepaidAgreementCancelled string = "PrepaidAgreementCancelled"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_PrepaidAgreementCancelled string = "5bf76b2a51e5780e089bc7d4f526e1d4577b7de423f281acb56a8c56d05704"

// PrepaidAgreementCancelled is the Go struct corresponding to the PrepaidAgreementCancelled event.
type PrepaidAgreementCancelled struct {
	BlockNumber uint64

	Target       Influence_Common_Types_Entity_Entity
	Permission   uint64
	Permitted    Influence_Common_Types_Entity_Entity
	EvictionTime uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewmatesExchanged

// ABI name for event
var Event_CrewmatesExchanged string = "CrewmatesExchanged"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewmatesExchanged string = "011179a9c5e4311bfde19c5306ff4358bf284a55d5069e8187cb6129c9b47a2a"

// CrewmatesExchanged is the Go struct corresponding to the CrewmatesExchanged event.
type CrewmatesExchanged struct {
	BlockNumber uint64

	Crew1               Influence_Common_Types_Entity_Entity
	Crew1CompositionOld Core_Array_Span_core_Integer_U64
	Crew1CompositionNew Core_Array_Span_core_Integer_U64
	Crew2               Influence_Common_Types_Entity_Entity
	Crew2CompositionOld Core_Array_Span_core_Integer_U64
	Crew2CompositionNew Core_Array_Span_core_Integer_U64
	Caller              string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SellOrderFilled

// ABI name for event
var Event_SellOrderFilled string = "SellOrderFilled"

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

// SellOrderFilled is the Go struct corresponding to the SellOrderFilled event.
type SellOrderFilled struct {
	BlockNumber uint64

	SellerCrew      Influence_Common_Types_Entity_Entity
	Exchange        Influence_Common_Types_Entity_Entity
	Product         uint64
	Amount          uint64
	Price           uint64
	Storage         Influence_Common_Types_Entity_Entity
	StorageSlot     uint64
	Destination     Influence_Common_Types_Entity_Entity
	DestinationSlot uint64
	CallerCrew      Influence_Common_Types_Entity_Entity
	Caller          string
}

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

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::array::Span::<influence::contracts::escrow::Withdrawal>

// Core_Array_Span_influence_Contracts_Escrow_Withdrawal is the Go struct corresponding to the core::array::Span::<influence::contracts::escrow::Withdrawal> struct.
type Core_Array_Span_influence_Contracts_Escrow_Withdrawal struct {
	Snapshot []Influence_Contracts_Escrow_Withdrawal
}

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

	value0, consumed, err := ParseArray[Influence_Contracts_Escrow_Withdrawal](ParseInfluence_Contracts_Escrow_Withdrawal)(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.Snapshot = value0
	currentIndex += consumed

	return result, currentIndex, nil
}

// ABI: influence::contracts::crew::Crew::BridgedFromL1

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_BridgedFromL1 string = "influence::contracts::crew::Crew::BridgedFromL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_BridgedFromL1 string = "01e27a21f2a2febcf4856da1a42f353e92351fc99ab9a5feb6d4170e91296923"

// Influence_Contracts_Crew_Crew_BridgedFromL1 is the Go struct corresponding to the influence::contracts::crew::Crew::BridgedFromL1 event.
type Influence_Contracts_Crew_Crew_BridgedFromL1 struct {
	BlockNumber uint64

	TokenId   *big.Int
	ToAddress string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::ApprovalForAll

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_ApprovalForAll string = "influence::contracts::ship::Ship::ApprovalForAll"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_ApprovalForAll string = "06ad9ed7b6318f1bcffefe19df9aeb40d22c36bed567e1925a5ccde0536edd"

// Influence_Contracts_Ship_Ship_ApprovalForAll is the Go struct corresponding to the influence::contracts::ship::Ship::ApprovalForAll event.
type Influence_Contracts_Ship_Ship_ApprovalForAll struct {
	BlockNumber uint64

	Owner    string
	Operator string
	Approved Core_Bool
}

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

	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.Operator = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: ResourceScanFinished

// ABI name for event
var Event_ResourceScanFinished string = "ResourceScanFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ResourceScanFinished string = "2f6e8eecbf460f39568068b9758116354b4cc857aa448c1eda56b9dd090599"

// ResourceScanFinished is the Go struct corresponding to the ResourceScanFinished event.
type ResourceScanFinished struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	Abundances Core_Array_Span_core_Integer_U128
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ConstructionAbandoned

// ABI name for event
var Event_ConstructionAbandoned string = "ConstructionAbandoned"

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

// ConstructionAbandoned is the Go struct corresponding to the ConstructionAbandoned event.
type ConstructionAbandoned struct {
	BlockNumber uint64

	Building   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::asteroid::Asteroid::SellOrderSet

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_SellOrderSet string = "influence::contracts::asteroid::Asteroid::SellOrderSet"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_SellOrderSet string = "0258bdf4f1e869ce324d405a5c9a25758a84c1e9bb6a527ba767d16fce4fcb8a"

// Influence_Contracts_Asteroid_Asteroid_SellOrderSet is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::SellOrderSet event.
type Influence_Contracts_Asteroid_Asteroid_SellOrderSet struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: LotReclaimed

// ABI name for event
var Event_LotReclaimed string = "LotReclaimed"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_LotReclaimed string = "5c0c06fec1df373ca8334cb2d2ea7c16a008b1d1c559a91ae0c548ae8304a6"

// LotReclaimed is the Go struct corresponding to the LotReclaimed event.
type LotReclaimed struct {
	BlockNumber uint64

	Lot        Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: BuyOrderCreated

// ABI name for event
var Event_BuyOrderCreated string = "BuyOrderCreated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_BuyOrderCreated string = "01930f6701012e23710325233da61de3d0a5b8333169de1709d0ac3d5e88872f"

// BuyOrderCreated is the Go struct corresponding to the BuyOrderCreated event.
type BuyOrderCreated struct {
	BlockNumber uint64

	Exchange    Influence_Common_Types_Entity_Entity
	Product     uint64
	Amount      uint64
	Price       uint64
	Storage     Influence_Common_Types_Entity_Entity
	StorageSlot uint64
	ValidTime   uint64
	MakerFee    uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crew::Crew::Approval

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_Approval string = "influence::contracts::crew::Crew::Approval"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_Approval string = "0134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff"

// Influence_Contracts_Crew_Crew_Approval is the Go struct corresponding to the influence::contracts::crew::Crew::Approval event.
type Influence_Contracts_Crew_Crew_Approval struct {
	BlockNumber uint64

	Owner    string
	Approved string
	TokenId  *big.Int
}

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

	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.Approved = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::sway::Sway::ConfirmationCreated

// ABI name for event
var Event_Influence_Contracts_Sway_Sway_ConfirmationCreated string = "influence::contracts::sway::Sway::ConfirmationCreated"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Sway_Sway_ConfirmationCreated string = "4ff9c92b4b06fc7d4923606d69abafc9051b0e41b0d7954692bd38be4b99e7"

// Influence_Contracts_Sway_Sway_ConfirmationCreated is the Go struct corresponding to the influence::contracts::sway::Sway::ConfirmationCreated event.
type Influence_Contracts_Sway_Sway_ConfirmationCreated struct {
	BlockNumber uint64

	From     string
	To       string
	Value    *big.Int
	Memo     string
	Consumer string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ConstructionPlanned

// ABI name for event
var Event_ConstructionPlanned string = "ConstructionPlanned"

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

// ConstructionPlanned is the Go struct corresponding to the ConstructionPlanned event.
type ConstructionPlanned struct {
	BlockNumber uint64

	Building       Influence_Common_Types_Entity_Entity
	BuildingType   uint64
	Asteroid       Influence_Common_Types_Entity_Entity
	Lot            Influence_Common_Types_Entity_Entity
	GracePeriodEnd uint64
	CallerCrew     Influence_Common_Types_Entity_Entity
	Caller         string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewDelegated

// ABI name for event
var Event_CrewDelegated string = "CrewDelegated"

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

// CrewDelegated is the Go struct corresponding to the CrewDelegated event.
type CrewDelegated struct {
	BlockNumber uint64

	DelegatedTo string
	Crew        Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::common::types::entity::Entity

// Influence_Common_Types_Entity_Entity is the Go struct corresponding to the influence::common::types::entity::Entity struct.
type Influence_Common_Types_Entity_Entity struct {
	Label uint64
	Id    uint64
}

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

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::ship::Ship::BridgedToL1

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_BridgedToL1 string = "influence::contracts::ship::Ship::BridgedToL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_BridgedToL1 string = "0343404fbb463bc14499440cae988896483e039778a9ed66bfaf125d4bc364cc"

// Influence_Contracts_Ship_Ship_BridgedToL1 is the Go struct corresponding to the influence::contracts::ship::Ship::BridgedToL1 event.
type Influence_Contracts_Ship_Ship_BridgedToL1 struct {
	BlockNumber uint64

	TokenId     *big.Int
	FromAddress string
	ToAddress   Core_Starknet_EthAddress_EthAddress
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewEjected

// ABI name for event
var Event_CrewEjected string = "CrewEjected"

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

// CrewEjected is the Go struct corresponding to the CrewEjected event.
type CrewEjected struct {
	BlockNumber uint64

	Station     Influence_Common_Types_Entity_Entity
	EjectedCrew Influence_Common_Types_Entity_Entity
	FinishTime  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ShipAssemblyStartedV1

// ABI name for event
var Event_ShipAssemblyStartedV1 string = "ShipAssemblyStartedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ShipAssemblyStartedV1 string = "0188b277b6bac6a7731bdd2fa5dd292bab7f1fc9becf7415dfb19d99815e6ab7"

// ShipAssemblyStartedV1 is the Go struct corresponding to the ShipAssemblyStartedV1 event.
type ShipAssemblyStartedV1 struct {
	BlockNumber uint64

	Ship        Influence_Common_Types_Entity_Entity
	ShipType    uint64
	DryDock     Influence_Common_Types_Entity_Entity
	DryDockSlot uint64
	Origin      Influence_Common_Types_Entity_Entity
	OriginSlot  uint64
	FinishTime  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SurfaceScanFinished

// ABI name for event
var Event_SurfaceScanFinished string = "SurfaceScanFinished"

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

// SurfaceScanFinished is the Go struct corresponding to the SurfaceScanFinished event.
type SurfaceScanFinished struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	Bonuses    uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: EmergencyPropellantCollected

// ABI name for event
var Event_EmergencyPropellantCollected string = "EmergencyPropellantCollected"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_EmergencyPropellantCollected string = "0288f431595bc70ad7c1e734871763ff2cdefd42f0b84427122e91522ee73b1b"

// EmergencyPropellantCollected is the Go struct corresponding to the EmergencyPropellantCollected event.
type EmergencyPropellantCollected struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	Amount     uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ContractPolicyRemoved

// ABI name for event
var Event_ContractPolicyRemoved string = "ContractPolicyRemoved"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ContractPolicyRemoved string = "0382b5a4bb2934a55ee0957aea461c14798960590f17e71425e35ca619c609e3"

// ContractPolicyRemoved is the Go struct corresponding to the ContractPolicyRemoved event.
type ContractPolicyRemoved struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ShipUndocked

// ABI name for event
var Event_ShipUndocked string = "ShipUndocked"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ShipUndocked string = "72de3827057a4cedd0ac04aec52fce94edec88aa651ae8fb6e4410b6aaf069"

// ShipUndocked is the Go struct corresponding to the ShipUndocked event.
type ShipUndocked struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	Dock       Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: ContractPolicyAssigned

// ABI name for event
var Event_ContractPolicyAssigned string = "ContractPolicyAssigned"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ContractPolicyAssigned string = "034f55828548ba737e210e484b2b707e53b2b221d3b83c42663b882618bfca42"

// ContractPolicyAssigned is the Go struct corresponding to the ContractPolicyAssigned event.
type ContractPolicyAssigned struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Permission uint64
	Contract   string
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: TransitStarted

// ABI name for event
var Event_TransitStarted string = "TransitStarted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_TransitStarted string = "02761565e17a1f79060ba5b036ec0cede61ab529bbf309a58f97538bf8c1027b"

// TransitStarted is the Go struct corresponding to the TransitStarted event.
type TransitStarted struct {
	BlockNumber uint64

	Ship        Influence_Common_Types_Entity_Entity
	Origin      Influence_Common_Types_Entity_Entity
	Destination Influence_Common_Types_Entity_Entity
	Departure   uint64
	Arrival     uint64
	FinishTime  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::escrow::Hook

// Influence_Contracts_Escrow_Hook is the Go struct corresponding to the influence::contracts::escrow::Hook struct.
type Influence_Contracts_Escrow_Hook struct {
	Contract           string
	EntryPointSelector string
	Calldata           Core_Array_Span_core_Felt252
}

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

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

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

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

	return result, currentIndex, nil
}

// ABI: CrewmateRecruitedV1

// ABI name for event
var Event_CrewmateRecruitedV1 string = "CrewmateRecruitedV1"

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

// CrewmateRecruitedV1 is the Go struct corresponding to the CrewmateRecruitedV1 event.
type CrewmateRecruitedV1 struct {
	BlockNumber uint64

	Crewmate    Influence_Common_Types_Entity_Entity
	Collection  uint64
	Class       uint64
	Title       uint64
	Impactful   Core_Array_Span_core_Integer_U64
	Cosmetic    Core_Array_Span_core_Integer_U64
	Gender      uint64
	Body        uint64
	Face        uint64
	Hair        uint64
	HairColor   uint64
	Clothes     uint64
	Head        uint64
	Item        uint64
	Name        string
	Station     Influence_Common_Types_Entity_Entity
	Composition Core_Array_Span_core_Integer_U64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	value17, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = value17
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: DeliveryPackaged

// ABI name for event
var Event_DeliveryPackaged string = "DeliveryPackaged"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DeliveryPackaged string = "01efe5ac10a84b083d3cf71bfff793dd83198ce7ef9a5426b1b30d9b81935aa3"

// DeliveryPackaged is the Go struct corresponding to the DeliveryPackaged event.
type DeliveryPackaged struct {
	BlockNumber uint64

	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	Products   Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Dest       Influence_Common_Types_Entity_Entity
	DestSlot   uint64
	Delivery   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: core::array::Span::<core::integer::u64>

// Core_Array_Span_core_Integer_U64 is the Go struct corresponding to the core::array::Span::<core::integer::u64> struct.
type Core_Array_Span_core_Integer_U64 struct {
	Snapshot []uint64
}

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

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

	return result, currentIndex, nil
}

// ABI: influence::contracts::asteroid::Asteroid::BridgedFromL1

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1 string = "influence::contracts::asteroid::Asteroid::BridgedFromL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Asteroid_Asteroid_BridgedFromL1 string = "01e27a21f2a2febcf4856da1a42f353e92351fc99ab9a5feb6d4170e91296923"

// Influence_Contracts_Asteroid_Asteroid_BridgedFromL1 is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::BridgedFromL1 event.
type Influence_Contracts_Asteroid_Asteroid_BridgedFromL1 struct {
	BlockNumber uint64

	TokenId   *big.Int
	ToAddress string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crewmate::Crewmate::ApprovalForAll

// ABI name for event
var Event_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll string = "influence::contracts::crewmate::Crewmate::ApprovalForAll"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crewmate_Crewmate_ApprovalForAll string = "06ad9ed7b6318f1bcffefe19df9aeb40d22c36bed567e1925a5ccde0536edd"

// Influence_Contracts_Crewmate_Crewmate_ApprovalForAll is the Go struct corresponding to the influence::contracts::crewmate::Crewmate::ApprovalForAll event.
type Influence_Contracts_Crewmate_Crewmate_ApprovalForAll struct {
	BlockNumber uint64

	Owner    string
	Operator string
	Approved Core_Bool
}

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

	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.Operator = value1
	currentIndex += consumed

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::crew::Crew::BridgedToL1

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_BridgedToL1 string = "influence::contracts::crew::Crew::BridgedToL1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_BridgedToL1 string = "0343404fbb463bc14499440cae988896483e039778a9ed66bfaf125d4bc364cc"

// Influence_Contracts_Crew_Crew_BridgedToL1 is the Go struct corresponding to the influence::contracts::crew::Crew::BridgedToL1 event.
type Influence_Contracts_Crew_Crew_BridgedToL1 struct {
	BlockNumber uint64

	TokenId     *big.Int
	FromAddress string
	ToAddress   Core_Starknet_EthAddress_EthAddress
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: CrewmatesArrangedV1

// ABI name for event
var Event_CrewmatesArrangedV1 string = "CrewmatesArrangedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_CrewmatesArrangedV1 string = "01a4527d06366f370dd689ea8fe186ab0e681a94edd846592b67197173f5ecea"

// CrewmatesArrangedV1 is the Go struct corresponding to the CrewmatesArrangedV1 event.
type CrewmatesArrangedV1 struct {
	BlockNumber uint64

	CompositionOld Core_Array_Span_core_Integer_U64
	CompositionNew Core_Array_Span_core_Integer_U64
	CallerCrew     Influence_Common_Types_Entity_Entity
	Caller         string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: influence::contracts::crew::Crew::Transfer

// ABI name for event
var Event_Influence_Contracts_Crew_Crew_Transfer string = "influence::contracts::crew::Crew::Transfer"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Crew_Crew_Transfer string = "99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"

// Influence_Contracts_Crew_Crew_Transfer is the Go struct corresponding to the influence::contracts::crew::Crew::Transfer event.
type Influence_Contracts_Crew_Crew_Transfer struct {
	BlockNumber uint64

	From    string
	To      string
	TokenId *big.Int
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::escrow::Escrow::ForcedWithdrawFinished

// ABI name for event
var Event_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished string = "influence::contracts::escrow::Escrow::ForcedWithdrawFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished string = "011bb50afc574e53cf2bbe684384041f5a24aea512e61d69a145ef87f018a564"

// Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished is the Go struct corresponding to the influence::contracts::escrow::Escrow::ForcedWithdrawFinished event.
type Influence_Contracts_Escrow_Escrow_ForcedWithdrawFinished struct {
	BlockNumber uint64

	OrderId string
	Caller  string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::ship::Ship::SellOrderSet

// ABI name for event
var Event_Influence_Contracts_Ship_Ship_SellOrderSet string = "influence::contracts::ship::Ship::SellOrderSet"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Ship_Ship_SellOrderSet string = "0258bdf4f1e869ce324d405a5c9a25758a84c1e9bb6a527ba767d16fce4fcb8a"

// Influence_Contracts_Ship_Ship_SellOrderSet is the Go struct corresponding to the influence::contracts::ship::Ship::SellOrderSet event.
type Influence_Contracts_Ship_Ship_SellOrderSet struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ShipCommandeered

// ABI name for event
var Event_ShipCommandeered string = "ShipCommandeered"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ShipCommandeered string = "0118a1ca7593e405c95a6c5f2d2c5a47e91186ea09084841e3617e1546ac4d6b"

// ShipCommandeered is the Go struct corresponding to the ShipCommandeered event.
type ShipCommandeered struct {
	BlockNumber uint64

	Ship       Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: DeliveryCancelled

// ABI name for event
var Event_DeliveryCancelled string = "DeliveryCancelled"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_DeliveryCancelled string = "010c30eb384eb39931c4fb26d9f9be36179ce00c4439ad00ec241b649dfca152"

// DeliveryCancelled is the Go struct corresponding to the DeliveryCancelled event.
type DeliveryCancelled struct {
	BlockNumber uint64

	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	Products   Core_Array_Span_influence_Common_Types_InventoryItem_InventoryItem
	Dest       Influence_Common_Types_Entity_Entity
	DestSlot   uint64
	Delivery   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SamplingDepositStartedV1

// ABI name for event
var Event_SamplingDepositStartedV1 string = "SamplingDepositStartedV1"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_SamplingDepositStartedV1 string = "032039be09b842863a6f4b375165b6053610e5ff9ad5e9707cd8bc524347b0ba"

// SamplingDepositStartedV1 is the Go struct corresponding to the SamplingDepositStartedV1 event.
type SamplingDepositStartedV1 struct {
	BlockNumber uint64

	Deposit    Influence_Common_Types_Entity_Entity
	Lot        Influence_Common_Types_Entity_Entity
	Resource   uint64
	Improving  Core_Bool
	Origin     Influence_Common_Types_Entity_Entity
	OriginSlot uint64
	FinishTime uint64
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: ShipAssemblyStarted

// ABI name for event
var Event_ShipAssemblyStarted string = "ShipAssemblyStarted"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_ShipAssemblyStarted string = "192752fb5963174574829304bf0d0495621c71d71b72cb866de671496fb496"

// ShipAssemblyStarted is the Go struct corresponding to the ShipAssemblyStarted event.
type ShipAssemblyStarted struct {
	BlockNumber uint64

	Ship        Influence_Common_Types_Entity_Entity
	DryDock     Influence_Common_Types_Entity_Entity
	DryDockSlot uint64
	ShipType    uint64
	FinishTime  uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: NameChanged

// ABI name for event
var Event_NameChanged string = "NameChanged"

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

// NameChanged is the Go struct corresponding to the NameChanged event.
type NameChanged struct {
	BlockNumber uint64

	Entity     Influence_Common_Types_Entity_Entity
	Name       Influence_Common_Types_String_String
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: TransitFinished

// ABI name for event
var Event_TransitFinished string = "TransitFinished"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_TransitFinished string = "0102fd7c0ddcb8814a0e6822fd9e408114ea8792462f5d2a5adb91bc26993442"

// TransitFinished is the Go struct corresponding to the TransitFinished event.
type TransitFinished struct {
	BlockNumber uint64

	Ship        Influence_Common_Types_Entity_Entity
	Origin      Influence_Common_Types_Entity_Entity
	Destination Influence_Common_Types_Entity_Entity
	Departure   uint64
	Arrival     uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::dispatcher::Dispatcher::ContractRegistered

// ABI name for event
var Event_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered string = "influence::contracts::dispatcher::Dispatcher::ContractRegistered"

// Starknet hash for the event, as it appears in Starknet event logs.
var Hash_Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered string = "0206ba27d5bbda42a63e108ee1ac7a6455c197ee34cd40a268e61b06f78dbc9a"

// Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered is the Go struct corresponding to the influence::contracts::dispatcher::Dispatcher::ContractRegistered event.
type Influence_Contracts_Dispatcher_Dispatcher_ContractRegistered struct {
	BlockNumber uint64

	Name    string
	Address string
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: influence::contracts::asteroid::Asteroid::SellOrderFilled

// ABI name for event
var Event_Influence_Contracts_Asteroid_Asteroid_SellOrderFilled string = "influence::contracts::asteroid::Asteroid::SellOrderFilled"

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

// Influence_Contracts_Asteroid_Asteroid_SellOrderFilled is the Go struct corresponding to the influence::contracts::asteroid::Asteroid::SellOrderFilled event.
type Influence_Contracts_Asteroid_Asteroid_SellOrderFilled struct {
	BlockNumber uint64

	TokenId *big.Int
	Price   *big.Int
}

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: AsteroidManaged

// ABI name for event
var Event_AsteroidManaged string = "AsteroidManaged"

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

// AsteroidManaged is the Go struct corresponding to the AsteroidManaged event.
type AsteroidManaged struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: SamplingDepositFinished

// ABI name for event
var Event_SamplingDepositFinished string = "SamplingDepositFinished"

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

// SamplingDepositFinished is the Go struct corresponding to the SamplingDepositFinished event.
type SamplingDepositFinished struct {
	BlockNumber uint64

	Deposit      Influence_Common_Types_Entity_Entity
	InitialYield uint64
	CallerCrew   Influence_Common_Types_Entity_Entity
	Caller       string
}

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

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

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

	value2, consumed, err := ParseInfluence_Common_Types_Entity_Entity(parameters[currentIndex:])
	if err != nil {
		return result, 0, err
	}
	result.CallerCrew = 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: SellOrderCreated

// ABI name for event
var Event_SellOrderCreated string = "SellOrderCreated"

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

// SellOrderCreated is the Go struct corresponding to the SellOrderCreated event.
type SellOrderCreated struct {
	BlockNumber uint64

	Exchange    Influence_Common_Types_Entity_Entity
	Product     uint64
	Amount      uint64
	Price       uint64
	Storage     Influence_Common_Types_Entity_Entity
	StorageSlot uint64
	ValidTime   uint64
	MakerFee    uint64
	CallerCrew  Influence_Common_Types_Entity_Entity
	Caller      string
}

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

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

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

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

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

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

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

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

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

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

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

	return result, currentIndex + 1, nil
}

// ABI: AsteroidPurchased

// ABI name for event
var Event_AsteroidPurchased string = "AsteroidPurchased"

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

// AsteroidPurchased is the Go struct corresponding to the AsteroidPurchased event.
type AsteroidPurchased struct {
	BlockNumber uint64

	Asteroid   Influence_Common_Types_Entity_Entity
	CallerCrew Influence_Common_Types_Entity_Entity
	Caller     string
}

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

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

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

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

	return result, currentIndex + 1, nil
}