rpc

type AddDeclareTransactionOutput struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	ClassHash       *felt.Felt `json:"class_hash"`
}

type AddDeclareTransactionResponse struct {
	Hash      *felt.Felt `json:"transaction_hash"`
	ClassHash *felt.Felt `json:"class_hash"`
}

type AddDeployAccountTransactionResponse struct {
	Hash            *felt.Felt `json:"transaction_hash"`
	ContractAddress *felt.Felt `json:"contract_address"`
}

type AddInvokeTransactionResponse struct {
	Hash *felt.Felt `json:"transaction_hash"`
}

type BinaryNode struct {
	// the hash of the left child
	Left *felt.Felt `json:"left"`
	// the hash of the right child
	Right *felt.Felt `json:"right"`
}

type Block struct {
	BlockHeader
	Status BlockStatus `json:"status"`
	// Transactions The transactions in this block
	Transactions []BlockTransaction `json:"transactions"`
}

type BlockBodyWithReceipts struct {
	Transactions []TransactionWithReceipt `json:"transactions"`
}

type BlockHashAndNumberOutput struct {
	Number uint64     `json:"block_number,omitempty"`
	Hash   *felt.Felt `json:"block_hash,omitempty"`
}

type BlockHeader struct {
	// Hash The hash of this block
	Hash *felt.Felt `json:"block_hash"`
	// ParentHash The hash of this block's parent
	ParentHash *felt.Felt `json:"parent_hash"`
	// Number the block number (its height)
	Number uint64 `json:"block_number"`
	// NewRoot The new global state root
	NewRoot *felt.Felt `json:"new_root"`
	// Timestamp the time in which the block was created, encoded in Unix time
	Timestamp uint64 `json:"timestamp"`
	// SequencerAddress the StarkNet identity of the sequencer submitting this block
	SequencerAddress *felt.Felt `json:"sequencer_address"`
	// The price of l1 gas in the block
	L1GasPrice ResourcePrice `json:"l1_gas_price"`
	// The price of l2 gas in the block
	L2GasPrice ResourcePrice `json:"l2_gas_price"`
	// The price of l1 data gas in the block
	L1DataGasPrice ResourcePrice `json:"l1_data_gas_price"`
	// Specifies whether the data of this block is published via blob data or calldata
	L1DAMode L1DAMode `json:"l1_da_mode"`
	// Semver of the current Starknet protocol
	StarknetVersion string `json:"starknet_version"`
}

type BlockID struct {
	Number *uint64    `json:"block_number,omitempty"`
	Hash   *felt.Felt `json:"block_hash,omitempty"`
	// A tag specifying a dynamic reference to a block. Tag `l1_accepted` refers
	// to the latest Starknet block which was included in a state update on L1 and
	// finalised by the consensus on L1. Tag `latest` refers to the latest Starknet
	// block finalised by the consensus on L2. Tag `pre_confirmed` refers to the block
	// which is currently being built by the block proposer in height `latest` + 1.
	Tag BlockTag `json:",omitempty"`
}

type BlockStatus string

type BlockTag string

type BlockTransaction struct {
	Hash *felt.Felt `json:"transaction_hash"`
	Transaction
}

type BlockTxHashes struct {
	BlockHeader
	Status BlockStatus `json:"status"`
	// Transactions The hashes of the transactions included in this block
	Transactions []*felt.Felt `json:"transactions"`
}

type BlockWithReceipts struct {
	BlockHeader
	Status BlockStatus `json:"status"`
	BlockBodyWithReceipts
}

type BroadcastDeclareTxnV3 struct {
	Type              TransactionType          `json:"type"`
	SenderAddress     *felt.Felt               `json:"sender_address"`
	CompiledClassHash *felt.Felt               `json:"compiled_class_hash"`
	Version           TransactionVersion       `json:"version"`
	Signature         []*felt.Felt             `json:"signature"`
	Nonce             *felt.Felt               `json:"nonce"`
	ContractClass     *contracts.ContractClass `json:"contract_class"`
	ResourceBounds    *ResourceBoundsMapping   `json:"resource_bounds"`
	Tip               U64                      `json:"tip"`
	// The data needed to allow the paymaster to pay for the transaction in native tokens
	PayMasterData []*felt.Felt `json:"paymaster_data"`
	// The data needed to deploy the account contract from which this tx will be initiated
	AccountDeploymentData []*felt.Felt `json:"account_deployment_data"`
	// The storage domain of the account's nonce (an account has a nonce per DA mode)
	NonceDataMode DataAvailabilityMode `json:"nonce_data_availability_mode"`
	// The storage domain of the account's balance from which fee will be charged
	FeeMode DataAvailabilityMode `json:"fee_data_availability_mode"`
}

type BroadcastDeployAccountTxnV3 = DeployAccountTxnV3

type BroadcastInvokeTxnV3 = InvokeTxnV3

type BroadcastTxn interface{}

type CallType string

type ClassOutput interface{}

type CompilationErrData struct {
	CompilationError string `json:"compilation_error"`
}

type ContractErrData struct {
	RevertError ContractExecutionError `json:"revert_error"`
}

type ContractExecutionError struct {
	// the error raised during execution
	Message              string
	ContractExecErrInner *ContractExecutionErrorInner
}

type ContractExecutionErrorInner struct {
	ContractAddress *felt.Felt              `json:"contract_address"`
	ClassHash       *felt.Felt              `json:"class_hash"`
	Selector        *felt.Felt              `json:"selector"`
	Error           *ContractExecutionError `json:"error"`
}

type ContractLeavesData struct {
	Nonce       *felt.Felt `json:"nonce"`
	ClassHash   *felt.Felt `json:"class_hash"`
	StorageRoot *felt.Felt `json:"storage_root,omitempty"`
}

type ContractNonce struct {
	// ContractAddress is the address of the contract
	ContractAddress *felt.Felt `json:"contract_address"`
	// Nonce is the nonce for the given address at the end of the block"
	Nonce *felt.Felt `json:"nonce"`
}

type ContractStorageDiffItem struct {
	// ContractAddress is the contract address for which the state changed
	Address        *felt.Felt     `json:"address"`
	StorageEntries []StorageEntry `json:"storage_entries"`
}

type ContractStorageKeys struct {
	ContractAddress *felt.Felt   `json:"contract_address"`
	StorageKeys     []*felt.Felt `json:"storage_keys"`
}

type ContractsProof struct {
	// The nodes in the union of the paths from the contracts tree root to the requested leaves
	Nodes              []NodeHashToNode     `json:"nodes"`
	ContractLeavesData []ContractLeavesData `json:"contract_leaves_data"`
}

type DataAvailabilityMode string

type DeclareTxnTrace struct {
	ValidateInvocation    *FnInvocation      `json:"validate_invocation,omitempty"`
	FeeTransferInvocation *FnInvocation      `json:"fee_transfer_invocation,omitempty"`
	StateDiff             *StateDiff         `json:"state_diff,omitempty"`
	Type                  TransactionType    `json:"type"`
	ExecutionResources    ExecutionResources `json:"execution_resources"`
}

type DeclareTxnType interface {
	GetSenderAddress() *felt.Felt
}

type DeclareTxnV0 struct {
	Type TransactionType `json:"type"`
	// SenderAddress the address of the account contract sending the declaration transaction
	SenderAddress *felt.Felt         `json:"sender_address"`
	MaxFee        *felt.Felt         `json:"max_fee"`
	Version       TransactionVersion `json:"version"`
	Signature     []*felt.Felt       `json:"signature"`
	ClassHash     *felt.Felt         `json:"class_hash"`
}

type DeclareTxnV1 struct {
	Type TransactionType `json:"type"`
	// SenderAddress the address of the account contract sending the declaration transaction
	SenderAddress *felt.Felt         `json:"sender_address"`
	MaxFee        *felt.Felt         `json:"max_fee"`
	Version       TransactionVersion `json:"version"`
	Signature     []*felt.Felt       `json:"signature"`
	Nonce         *felt.Felt         `json:"nonce"`
	// ClassHash the hash of the declared class
	ClassHash *felt.Felt `json:"class_hash"`
}

type DeclareTxnV2 struct {
	Type TransactionType `json:"type"`
	// SenderAddress the address of the account contract sending the declaration transaction
	SenderAddress     *felt.Felt         `json:"sender_address"`
	CompiledClassHash *felt.Felt         `json:"compiled_class_hash"`
	MaxFee            *felt.Felt         `json:"max_fee"`
	Version           TransactionVersion `json:"version"`
	Signature         []*felt.Felt       `json:"signature"`
	Nonce             *felt.Felt         `json:"nonce"`
	ClassHash         *felt.Felt         `json:"class_hash"`
}

type DeclareTxnV3 struct {
	Type              TransactionType        `json:"type"`
	SenderAddress     *felt.Felt             `json:"sender_address"`
	CompiledClassHash *felt.Felt             `json:"compiled_class_hash"`
	Version           TransactionVersion     `json:"version"`
	Signature         []*felt.Felt           `json:"signature"`
	Nonce             *felt.Felt             `json:"nonce"`
	ClassHash         *felt.Felt             `json:"class_hash"`
	ResourceBounds    *ResourceBoundsMapping `json:"resource_bounds"`
	Tip               U64                    `json:"tip"`
	// The data needed to allow the paymaster to pay for the transaction in native tokens
	PayMasterData []*felt.Felt `json:"paymaster_data"`
	// The data needed to deploy the account contract from which this tx will be initiated
	AccountDeploymentData []*felt.Felt `json:"account_deployment_data"`
	// The storage domain of the account's nonce (an account has a nonce per DA mode)
	NonceDataMode DataAvailabilityMode `json:"nonce_data_availability_mode"`
	// The storage domain of the account's balance from which fee will be charged
	FeeMode DataAvailabilityMode `json:"fee_data_availability_mode"`
}

type DeclaredClassesItem struct {
	// The hash of the declared class
	ClassHash *felt.Felt `json:"class_hash"`
	// The Cairo assembly hash corresponding to the declared class
	CompiledClassHash *felt.Felt `json:"compiled_class_hash"`
}

type DeployAccountTxnTrace struct {
	ValidateInvocation *FnInvocation `json:"validate_invocation,omitempty"`
	// the trace of the constructor call
	ConstructorInvocation FnInvocation       `json:"constructor_invocation"`
	FeeTransferInvocation *FnInvocation      `json:"fee_transfer_invocation,omitempty"`
	StateDiff             *StateDiff         `json:"state_diff,omitempty"`
	Type                  TransactionType    `json:"type"`
	ExecutionResources    ExecutionResources `json:"execution_resources"`
}

type DeployAccountTxnV1 struct {
	MaxFee    *felt.Felt         `json:"max_fee"`
	Version   TransactionVersion `json:"version"`
	Signature []*felt.Felt       `json:"signature"`
	Nonce     *felt.Felt         `json:"nonce"`
	Type      TransactionType    `json:"type"`
	// ClassHash The hash of the deployed contract's class
	ClassHash *felt.Felt `json:"class_hash"`

	// ContractAddressSalt The salt for the address of the deployed contract
	ContractAddressSalt *felt.Felt `json:"contract_address_salt"`

	// ConstructorCalldata The parameters passed to the constructor
	ConstructorCalldata []*felt.Felt `json:"constructor_calldata"`
}

type DeployAccountTxnV3 struct {
	Type                TransactionType        `json:"type"`
	Version             TransactionVersion     `json:"version"`
	Signature           []*felt.Felt           `json:"signature"`
	Nonce               *felt.Felt             `json:"nonce"`
	ContractAddressSalt *felt.Felt             `json:"contract_address_salt"`
	ConstructorCalldata []*felt.Felt           `json:"constructor_calldata"`
	ClassHash           *felt.Felt             `json:"class_hash"`
	ResourceBounds      *ResourceBoundsMapping `json:"resource_bounds"`
	Tip                 U64                    `json:"tip"`
	// The data needed to allow the paymaster to pay for the transaction in native tokens
	PayMasterData []*felt.Felt `json:"paymaster_data"`
	// The storage domain of the account's nonce (an account has a nonce per DA mode)
	NonceDataMode DataAvailabilityMode `json:"nonce_data_availability_mode"`
	// The storage domain of the account's balance from which fee will be charged
	FeeMode DataAvailabilityMode `json:"fee_data_availability_mode"`
}

type DeployAccountType interface {
	GetConstructorCalldata() []*felt.Felt
}

type DeployTxn struct {
	// ClassHash The hash of the deployed contract's class
	ClassHash *felt.Felt `json:"class_hash"`

	Version             TransactionVersion `json:"version"`
	Type                TransactionType    `json:"type"`
	ContractAddressSalt *felt.Felt         `json:"contract_address_salt"`
	ConstructorCalldata []*felt.Felt       `json:"constructor_calldata"`
}

type DeployedContractItem struct {
	// ContractAddress is the address of the contract
	Address *felt.Felt `json:"address"`
	// ClassHash is the hash of the contract code
	ClassHash *felt.Felt `json:"class_hash"`
}

type EdgeNode struct {
	// an unsigned integer whose binary representation represents the path from the current node
	// to its highest non-zero descendant (bounded by 2^251)
	Path NumAsHex `json:"path"`
	// the length of the path (bounded by 251)
	Length uint `json:"length"`
	// the hash of the unique non-zero maximal-height descendant node
	Child *felt.Felt `json:"child"`
}

type EmittedEvent struct {
	Event
	// BlockHash the hash of the block in which the event was emitted
	BlockHash *felt.Felt `json:"block_hash,omitempty"`
	// BlockNumber the number of the block in which the event was emitted
	BlockNumber uint64 `json:"block_number,omitempty"`
	// TransactionHash the transaction that emitted the event
	TransactionHash *felt.Felt `json:"transaction_hash"`
}

type EmittedEventWithFinalityStatus struct {
	EmittedEvent
	FinalityStatus TxnFinalityStatus `json:"finality_status"`
}

type EntryPointType string

type Event struct {
	FromAddress *felt.Felt `json:"from_address"`
	EventContent
}

type EventChunk struct {
	Events            []EmittedEvent `json:"events"`
	ContinuationToken string         `json:"continuation_token,omitempty"`
}

type EventContent struct {
	Keys []*felt.Felt `json:"keys"`
	Data []*felt.Felt `json:"data"`
}

type EventFilter struct {
	// FromBlock from block
	FromBlock BlockID `json:"from_block,omitempty"`
	// ToBlock to block
	ToBlock BlockID `json:"to_block,omitempty"`
	// Address from contract
	Address *felt.Felt `json:"address,omitempty"`
	// Keys the values used to filter the events
	Keys [][]*felt.Felt `json:"keys,omitempty"`
}

type EventSubscriptionInput struct {
	// (Optional) Filter events by from_address which emitted the event
	FromAddress *felt.Felt `json:"from_address,omitempty"`
	// (Optional) Per key (by position), designate the possible values to be
	// matched for events to be returned. Empty array designates 'any' value
	Keys [][]*felt.Felt `json:"keys,omitempty"`
	// (Optional) The block to get notifications from, default is latest, limited to 1024 blocks back
	SubBlockID SubscriptionBlockID `json:"block_id,omitzero"`
	// (Optional) The finality status of the most recent events to include.
	// Only `PRE_CONFIRMED` and `ACCEPTED_ON_L2` are supported. Default is `ACCEPTED_ON_L2`.
	// If PRE_CONFIRMED finality is selected, events might appear multiple times, once for each finality status update.
	FinalityStatus TxnFinalityStatus `json:"finality_status,omitempty"`
}

type EventsInput struct {
	EventFilter
	ResultPageRequest
}

type ExecInvocation struct {
	*FnInvocation
	// the revert reason for the failed invocation
	RevertReason string `json:"revert_reason,omitempty"`
}

type ExecutionResources struct {
	// l1 gas consumed by this transaction, used for l2-->l1 messages and state updates if blobs are not used
	L1Gas uint `json:"l1_gas"`
	// data gas consumed by this transaction, 0 if blobs are not used
	L1DataGas uint `json:"l1_data_gas"`
	// l2 gas consumed by this transaction, used for computation and calldata
	L2Gas uint `json:"l2_gas"`
}

type FeeEstimation struct {
	FeeEstimationCommon
	// Units in which the fee is given, can only be FRI
	Unit PriceUnitFri `json:"unit"`
}

type FeeEstimationCommon struct {
	// The Ethereum gas consumption of the transaction, charged for L1->L2 messages and, depending on the block's DA_MODE, state diffs
	L1GasConsumed *felt.Felt `json:"l1_gas_consumed"`

	// The gas price (in wei or fri, depending on the tx version) that was used in the cost estimation.
	L1GasPrice *felt.Felt `json:"l1_gas_price"`

	// The L2 gas consumption of the transaction
	L2GasConsumed *felt.Felt `json:"l2_gas_consumed"`

	// The L2 gas price (in wei or fri, depending on the tx version) that was used in the cost estimation.
	L2GasPrice *felt.Felt `json:"l2_gas_price"`

	// The Ethereum data gas consumption of the transaction.
	L1DataGasConsumed *felt.Felt `json:"l1_data_gas_consumed"`

	// The data gas price (in wei or fri, depending on the tx version) that was used in the cost estimation.
	L1DataGasPrice *felt.Felt `json:"l1_data_gas_price"`

	// The estimated fee for the transaction (in wei or fri, depending on the tx version), equals to
	// gas_consumed*gas_price + data_gas_consumed*data_gas_price.
	OverallFee *felt.Felt `json:"overall_fee"`
}

type FeePayment struct {
	Amount *felt.Felt `json:"amount"`
	Unit   PriceUnit  `json:"unit"`
}

type FnInvocation struct {
	FunctionCall

	// The address of the invoking contract. 0 for the root invocation
	CallerAddress *felt.Felt `json:"caller_address"`

	// The hash of the class being called
	ClassHash *felt.Felt `json:"class_hash"`

	EntryPointType EntryPointType `json:"entry_point_type"`

	CallType CallType `json:"call_type"`

	// The value returned from the function invocation
	Result []*felt.Felt `json:"result"`

	// The calls made by this invocation
	NestedCalls []FnInvocation `json:"calls"`

	// The events emitted in this invocation
	InvocationEvents []OrderedEvent `json:"events"`

	// The messages sent by this invocation to L1
	L1Messages []OrderedMsg `json:"messages"`

	// Resources consumed by the internal call
	ExecutionResources InnerCallExecutionResources `json:"execution_resources"`

	// True if this inner call panicked
	IsReverted bool `json:"is_reverted"`
}

type FunctionCall struct {
	ContractAddress    *felt.Felt `json:"contract_address"`
	EntryPointSelector *felt.Felt `json:"entry_point_selector"`

	// Calldata The parameters passed to the function
	Calldata []*felt.Felt `json:"calldata"`
}

type GlobalRoots struct {
	ContractsTreeRoot *felt.Felt `json:"contracts_tree_root"`
	ClassesTreeRoot   *felt.Felt `json:"classes_tree_root"`
	// the associated block hash (needed in case the caller used a block tag for the block_id parameter)
	BlockHash *felt.Felt `json:"block_hash"`
}

type InnerCallExecutionResources struct {
	// l1 gas consumed by this transaction, used for l2-->l1 messages and state updates if blobs are not used
	L1Gas uint `json:"l1_gas"`
	// l2 gas consumed by this transaction, used for computation and calldata
	L2Gas uint `json:"l2_gas"`
}

type InvokeFunctionCall struct {
	// The address of the contract to invoke
	ContractAddress *felt.Felt
	// The name of the function to invoke
	FunctionName string
	// The parameters passed to the function
	CallData []*felt.Felt
}

type InvokeTxnTrace struct {
	ValidateInvocation *FnInvocation `json:"validate_invocation,omitempty"`
	// the trace of the __execute__ call
	ExecuteInvocation     ExecInvocation     `json:"execute_invocation"`
	FeeTransferInvocation *FnInvocation      `json:"fee_transfer_invocation,omitempty"`
	StateDiff             *StateDiff         `json:"state_diff,omitempty"`
	Type                  TransactionType    `json:"type"`
	ExecutionResources    ExecutionResources `json:"execution_resources"`
}

type InvokeTxnType interface {
	GetCalldata() []*felt.Felt
}

type InvokeTxnV0 struct {
	Type      TransactionType    `json:"type"`
	MaxFee    *felt.Felt         `json:"max_fee"`
	Version   TransactionVersion `json:"version"`
	Signature []*felt.Felt       `json:"signature"`
	FunctionCall
}

type InvokeTxnV1 struct {
	MaxFee        *felt.Felt         `json:"max_fee"`
	Version       TransactionVersion `json:"version"`
	Signature     []*felt.Felt       `json:"signature"`
	Nonce         *felt.Felt         `json:"nonce"`
	Type          TransactionType    `json:"type"`
	SenderAddress *felt.Felt         `json:"sender_address"`
	// The data expected by the account's `execute` function (in most usecases, this includes the
	// called contract address and a function selector)
	Calldata []*felt.Felt `json:"calldata"`
}

type InvokeTxnV3 struct {
	Type           TransactionType        `json:"type"`
	SenderAddress  *felt.Felt             `json:"sender_address"`
	Calldata       []*felt.Felt           `json:"calldata"`
	Version        TransactionVersion     `json:"version"`
	Signature      []*felt.Felt           `json:"signature"`
	Nonce          *felt.Felt             `json:"nonce"`
	ResourceBounds *ResourceBoundsMapping `json:"resource_bounds"`
	Tip            U64                    `json:"tip"`
	// The data needed to allow the paymaster to pay for the transaction in native tokens
	PayMasterData []*felt.Felt `json:"paymaster_data"`
	// The data needed to deploy the account contract from which this tx will be initiated
	AccountDeploymentData []*felt.Felt `json:"account_deployment_data"`
	// The storage domain of the account's nonce (an account has a nonce per DA mode)
	NonceDataMode DataAvailabilityMode `json:"nonce_data_availability_mode"`
	// The storage domain of the account's balance from which fee will be charged
	FeeMode DataAvailabilityMode `json:"fee_data_availability_mode"`
}

type L1DAMode int

type L1HandlerTxn struct {
	Type TransactionType `json:"type"`
	// Version of the transaction scheme
	Version TransactionVersion `json:"version"`
	// Nonce
	Nonce string `json:"nonce"`
	FunctionCall
}

type L1HandlerTxnTrace struct {
	// the trace of the L1 handler call
	FunctionInvocation FnInvocation       `json:"function_invocation"`
	StateDiff          *StateDiff         `json:"state_diff,omitempty"`
	ExecutionResources ExecutionResources `json:"execution_resources"`
	Type               TransactionType    `json:"type"`
}

type MerkleNode struct {
	Type string
	Data any
}

type MessageFeeEstimation struct {
	FeeEstimationCommon
	// Units in which the fee is given, can only be WEI
	Unit PriceUnitWei `json:"unit"`
}

type MessageStatus struct {
	// The hash of the L1_HANDLER transaction in L2 that contains the message
	Hash *felt.Felt `json:"transaction_hash"`
	// The finality status of the L1_HANDLER transaction, including the case the txn is still in the mempool or
	// failed validation during the block construction phase
	FinalityStatus TxnFinalityStatus `json:"finality_status"`
	// The execution status of the L1_HANDLER transaction
	ExecutionStatus TxnExecutionStatus `json:"execution_status"`
	// The failure reason. Only appears if `execution_status` is REVERTED
	FailureReason string `json:"failure_reason,omitempty"`
}

type MsgFromL1 struct {
	// FromAddress The address of the L1 contract sending the message
	FromAddress string `json:"from_address"`
	// ToAddress The target L2 address the message is sent to
	ToAddress *felt.Felt `json:"to_address"`
	// EntryPointSelector The selector of the l1_handler in invoke in the target contract
	Selector *felt.Felt `json:"entry_point_selector"`
	// Payload  The payload of the message
	Payload []*felt.Felt `json:"payload"`
}

type MsgToL1 struct {
	// FromAddress The address of the L2 contract sending the message
	FromAddress *felt.Felt `json:"from_address"`
	// ToAddress The target L1 address the message is sent to
	ToAddress *felt.Felt `json:"to_address"`
	// Payload  The payload of the message
	Payload []*felt.Felt `json:"payload"`
}

type NewTxnStatus struct {
	TransactionHash *felt.Felt      `json:"transaction_hash"`
	Status          TxnStatusResult `json:"status"`
}

type NodeHashToNode struct {
	NodeHash *felt.Felt `json:"node_hash"`
	Node     MerkleNode `json:"node"`
}

type NumAsHex string

type OrderedEvent struct {
	// The order of the event within the transaction
	Order int `json:"order"`
	*EventContent
}

type OrderedMsg struct {
	// The order of the message within the transaction
	Order   int `json:"order"`
	MsgToL1 MsgToL1
}

type Pre_confirmedBlock struct {
	Pre_confirmedBlockHeader
	Transactions []BlockTransaction `json:"transactions"`
}

type Pre_confirmedBlockHeader struct {
	// The block number of the block that the proposer is currently building.
	// Note that this is a local view of the node, whose accuracy depends on its polling interval length.
	Number uint64 `json:"block_number"`
	// Timestamp the time in which the block was created, encoded in Unix time
	Timestamp uint64 `json:"timestamp"`
	// SequencerAddress the StarkNet identity of the sequencer submitting this block
	SequencerAddress *felt.Felt `json:"sequencer_address"`
	// The price of l1 gas in the block
	L1GasPrice ResourcePrice `json:"l1_gas_price"`
	// The price of l2 gas in the block
	L2GasPrice ResourcePrice `json:"l2_gas_price"`
	// Semver of the current Starknet protocol
	StarknetVersion string `json:"starknet_version"`
	// The price of l1 data gas in the block
	L1DataGasPrice ResourcePrice `json:"l1_data_gas_price"`
	// Specifies whether the data of this block is published via blob data or calldata
	L1DAMode L1DAMode `json:"l1_da_mode"`
}

type Pre_confirmedBlockTxHashes struct {
	Pre_confirmedBlockHeader
	Transactions []*felt.Felt `json:"transactions"`
}

type Pre_confirmedBlockWithReceipts struct {
	Pre_confirmedBlockHeader
	BlockBodyWithReceipts
}

type Pre_confirmedStateUpdate struct {
	// OldRoot is the previous global state root.
	OldRoot   *felt.Felt `json:"old_root"`
	StateDiff StateDiff  `json:"state_diff"`
}

type PriceUnit string

type PriceUnitFri string

type PriceUnitWei string

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

type RPCData interface {
	ErrorMessage() string
}

type RPCError struct {
	Code    int     `json:"code"`
	Message string  `json:"message"`
	Data    RPCData `json:"data,omitempty"`
}

type ReplacedClassesItem struct {
	// The address of the contract whose class was replaced
	ContractClass *felt.Felt `json:"contract_address"`
	// The new class hash
	ClassHash *felt.Felt `json:"class_hash"`
}

type Resource string

type ResourceBounds struct {
	// The max amount of the resource that can be used in the tx
	MaxAmount U64 `json:"max_amount"`
	// The max price per unit of this resource for this tx
	MaxPricePerUnit U128 `json:"max_price_per_unit"`
}

type ResourceBoundsMapping struct {
	// The max amount and max price per unit of L1 gas used in this tx
	L1Gas ResourceBounds `json:"l1_gas"`
	// The max amount and max price per unit of L1 blob gas used in this tx
	L1DataGas ResourceBounds `json:"l1_data_gas"`
	// The max amount and max price per unit of L2 gas used in this tx
	L2Gas ResourceBounds `json:"l2_gas"`
}

type ResourcePrice struct {
	// the price of one unit of the given resource, denominated in fri (10^-18 strk)
	PriceInFRI *felt.Felt `json:"price_in_fri,omitempty"`
	// The price of one unit of the given resource, denominated in wei
	PriceInWei *felt.Felt `json:"price_in_wei"`
}

type ResultPageRequest struct {
	// a pointer to the last element of the delivered page, use this token in a subsequent query to obtain the next page
	ContinuationToken string `json:"continuation_token,omitempty"`
	ChunkSize         int    `json:"chunk_size"`
}

type RpcProvider interface {
	AddInvokeTransaction(ctx context.Context, invokeTxn *BroadcastInvokeTxnV3) (*AddInvokeTransactionResponse, error)
	AddDeclareTransaction(ctx context.Context, declareTransaction *BroadcastDeclareTxnV3) (*AddDeclareTransactionResponse, error)
	AddDeployAccountTransaction(
		ctx context.Context,
		deployAccountTransaction *BroadcastDeployAccountTxnV3,
	) (*AddDeployAccountTransactionResponse, error)
	BlockHashAndNumber(ctx context.Context) (*BlockHashAndNumberOutput, error)
	BlockNumber(ctx context.Context) (uint64, error)
	BlockTransactionCount(ctx context.Context, blockID BlockID) (uint64, error)
	BlockWithReceipts(ctx context.Context, blockID BlockID) (interface{}, error)
	BlockWithTxHashes(ctx context.Context, blockID BlockID) (interface{}, error)
	BlockWithTxs(ctx context.Context, blockID BlockID) (interface{}, error)
	Call(ctx context.Context, call FunctionCall, block BlockID) ([]*felt.Felt, error)
	ChainID(ctx context.Context) (string, error)
	Class(ctx context.Context, blockID BlockID, classHash *felt.Felt) (ClassOutput, error)
	ClassAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (ClassOutput, error)
	ClassHashAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*felt.Felt, error)
	CompiledCasm(ctx context.Context, classHash *felt.Felt) (*contracts.CasmClass, error)
	EstimateFee(ctx context.Context, requests []BroadcastTxn, simulationFlags []SimulationFlag, blockID BlockID) ([]FeeEstimation, error)
	EstimateMessageFee(ctx context.Context, msg MsgFromL1, blockID BlockID) (MessageFeeEstimation, error)
	Events(ctx context.Context, input EventsInput) (*EventChunk, error)
	GetStorageProof(ctx context.Context, storageProofInput StorageProofInput) (*StorageProofResult, error)
	GetTransactionStatus(ctx context.Context, transactionHash *felt.Felt) (*TxnStatusResult, error)
	GetMessagesStatus(ctx context.Context, transactionHash NumAsHex) ([]MessageStatus, error)
	Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*felt.Felt, error)
	SimulateTransactions(
		ctx context.Context,
		blockID BlockID,
		txns []BroadcastTxn,
		simulationFlags []SimulationFlag,
	) ([]SimulatedTransaction, error)
	StateUpdate(ctx context.Context, blockID BlockID) (*StateUpdateOutput, error)
	StorageAt(ctx context.Context, contractAddress *felt.Felt, key string, blockID BlockID) (string, error)
	SpecVersion(ctx context.Context) (string, error)
	Syncing(ctx context.Context) (SyncStatus, error)
	TraceBlockTransactions(ctx context.Context, blockID BlockID) ([]Trace, error)
	TransactionByBlockIdAndIndex(ctx context.Context, blockID BlockID, index uint64) (*BlockTransaction, error)
	TransactionByHash(ctx context.Context, hash *felt.Felt) (*BlockTransaction, error)
	TransactionReceipt(ctx context.Context, transactionHash *felt.Felt) (*TransactionReceiptWithBlockInfo, error)
	TraceTransaction(ctx context.Context, transactionHash *felt.Felt) (TxnTrace, error)
}

type SimulateTransactionInput struct {
	// a sequence of transactions to simulate, running each transaction on the state resulting from applying all the previous ones
	Txns            []BroadcastTxn   `json:"transactions"`
	BlockID         BlockID          `json:"block_id"`
	SimulationFlags []SimulationFlag `json:"simulation_flags"`
}

type SimulatedTransaction struct {
	TxnTrace      `json:"transaction_trace"`
	FeeEstimation `json:"fee_estimation"`
}

type SimulationFlag string

type StateDiff struct {
	// list storage changes
	StorageDiffs []ContractStorageDiffItem `json:"storage_diffs"`
	// a list of Deprecated declared classes
	DeprecatedDeclaredClasses []*felt.Felt `json:"deprecated_declared_classes"`
	// list of DeclaredClassesItems objects
	DeclaredClasses []DeclaredClassesItem `json:"declared_classes"`
	// list of new contract deployed as part of the state update
	DeployedContracts []DeployedContractItem `json:"deployed_contracts"`
	// list of contracts whose class was replaced
	ReplacedClasses []ReplacedClassesItem `json:"replaced_classes"`
	// Nonces provides the updated nonces per contract addresses
	Nonces []ContractNonce `json:"nonces"`
}

type StateUpdateOutput struct {
	// BlockHash is the block identifier. Nil for pre_confirmed block.
	BlockHash *felt.Felt `json:"block_hash"`
	// NewRoot is the new global state root. Nil for pre_confirmed block.
	NewRoot *felt.Felt `json:"new_root"`
	Pre_confirmedStateUpdate
}

type StorageEntry struct {
	Key   *felt.Felt `json:"key"`
	Value *felt.Felt `json:"value"`
}

type StorageProofInput struct {
	// Required. The hash of the requested block, or number (height) of the requested block, or a block tag
	BlockID BlockID `json:"block_id"`
	// Optional. A list of the class hashes for which we want to prove membership in the classes trie
	ClassHashes []*felt.Felt `json:"class_hashes,omitempty"`
	// Optional. A list of contracts for which we want to prove membership in the global state trie
	ContractAddresses []*felt.Felt `json:"contract_addresses,omitempty"`
	// Optional. A list of (contract_address, storage_keys) pairs
	ContractsStorageKeys []ContractStorageKeys `json:"contracts_storage_keys,omitempty"`
}

type StorageProofResult struct {
	ClassesProof           []NodeHashToNode   `json:"classes_proof"`
	ContractsProof         ContractsProof     `json:"contracts_proof"`
	ContractsStorageProofs [][]NodeHashToNode `json:"contracts_storage_proofs"`
	GlobalRoots            GlobalRoots        `json:"global_roots"`
}

type StringErrData string

type SubNewTxnReceiptsInput struct {
	// Optional: A vector of finality statuses to receive updates for.
	// Only `PRE_CONFIRMED` and `ACCEPTED_ON_L2` are supported. Default is `ACCEPTED_ON_L2`.
	FinalityStatus []TxnFinalityStatus `json:"finality_status,omitempty"`
	// Optional: Filter transaction receipts to only include transactions sent by the specified addresses
	SenderAddress []*felt.Felt `json:"sender_address,omitempty"`
}

type SubNewTxnsInput struct {
	// Optional: A vector of finality statuses to receive updates for.
	// Support all transaction statuses, except `ACCEPTED_ON_L1`. Default is `ACCEPTED_ON_L2`.
	FinalityStatus []TxnStatus `json:"finality_status,omitempty"`
	// Optional: Filter transaction receipts to only include transactions sent by the specified addresses
	SenderAddress []*felt.Felt `json:"sender_address,omitempty"`
}

type SubscriptionBlockID BlockID

type SyncStatus struct {
	// A boolean indicating whether the node is syncing. If false, all other fields are empty.
	IsSyncing bool

	// All these fields are only present if IsSyncing is true.
	StartingBlockHash *felt.Felt `json:"starting_block_hash,omitempty"`
	StartingBlockNum  uint64     `json:"starting_block_num,omitempty"`
	CurrentBlockHash  *felt.Felt `json:"current_block_hash,omitempty"`
	CurrentBlockNum   uint64     `json:"current_block_num,omitempty"`
	HighestBlockHash  *felt.Felt `json:"highest_block_hash,omitempty"`
	HighestBlockNum   uint64     `json:"highest_block_num,omitempty"`
}

type Trace struct {
	TraceRoot TxnTrace   `json:"trace_root,omitempty"`
	TxnHash   *felt.Felt `json:"transaction_hash,omitempty"`
}

type TraceStatus string

type TraceStatusErrData struct {
	Status TraceStatus `json:"status"`
}

type Transaction interface {
	GetType() TransactionType
	GetVersion() TransactionVersion
}

type TransactionExecErrData struct {
	TransactionIndex int                    `json:"transaction_index"`
	ExecutionError   ContractExecutionError `json:"execution_error"`
}

type TransactionReceipt struct {
	Hash               *felt.Felt         `json:"transaction_hash"`
	Type               TransactionType    `json:"type"`
	ActualFee          FeePayment         `json:"actual_fee"`
	FinalityStatus     TxnFinalityStatus  `json:"finality_status"`
	MessagesSent       []MsgToL1          `json:"messages_sent"`
	Events             []Event            `json:"events"`
	ExecutionResources ExecutionResources `json:"execution_resources"`
	ExecutionStatus    TxnExecutionStatus `json:"execution_status"`
	// Only present in case of a Deploy or DeployAccount transaction receipt
	ContractAddress *felt.Felt `json:"contract_address,omitempty"`
	// Only appears if the transaction is a L1Handler transaction
	MessageHash NumAsHex `json:"message_hash,omitempty"`
	// Only appears if execution_status is REVERTED
	RevertReason string `json:"revert_reason,omitempty"`
}

type TransactionReceiptWithBlockInfo struct {
	TransactionReceipt
	BlockHash   *felt.Felt `json:"block_hash,omitempty"`
	BlockNumber uint       `json:"block_number,omitempty"`
}

type TransactionResponse struct {
	// Present for all transaction types
	Hash *felt.Felt `json:"transaction_hash"`
	// Present only for declare transactions
	ClassHash *felt.Felt `json:"class_hash,omitempty"`
	// Present only for deploy transactions
	ContractAddress *felt.Felt `json:"contract_address,omitempty"`
}

type TransactionType string

type TransactionVersion string

type TransactionWithReceipt struct {
	Transaction BlockTransaction   `json:"transaction"`
	Receipt     TransactionReceipt `json:"receipt"`
}

type TxDetails struct {
	Nonce   *felt.Felt
	MaxFee  *felt.Felt
	Version TransactionVersion
}

type TxnExecutionStatus string

type TxnFinalityStatus string

type TxnStatus string

type TxnStatusResult struct {
	FinalityStatus  TxnStatus          `json:"finality_status"`
	ExecutionStatus TxnExecutionStatus `json:"execution_status,omitempty"`
	// the failure reason, only appears if execution_status is REVERTED
	FailureReason string `json:"failure_reason,omitempty"`
}

type TxnTrace interface{}

type TxnWithHashAndStatus struct {
	// Transaction with hash and status
	BlockTransaction
	// Finality status of the transaction, except `ACCEPTED_ON_L1`.
	FinalityStatus TxnStatus `json:"finality_status"`
}

type U128 string

type U64 string

type WebsocketProvider interface {
	SubscribeEvents(
		ctx context.Context,
		events chan<- *EmittedEventWithFinalityStatus,
		options *EventSubscriptionInput,
	) (*client.ClientSubscription, error)
	SubscribeNewHeads(ctx context.Context, headers chan<- *BlockHeader, subBlockID SubscriptionBlockID) (*client.ClientSubscription, error)
	SubscribeNewTransactions(
		ctx context.Context,
		newTxns chan<- *TxnWithHashAndStatus,
		options *SubNewTxnsInput,
	) (*client.ClientSubscription, error)
	SubscribeNewTransactionReceipts(
		ctx context.Context,
		txnReceipts chan<- *TransactionReceiptWithBlockInfo,
		options *SubNewTxnReceiptsInput,
	) (*client.ClientSubscription, error)
	SubscribeTransactionStatus(
		ctx context.Context,
		newStatus chan<- *NewTxnStatus,
		transactionHash *felt.Felt,
	) (*client.ClientSubscription, error)
}

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