rpc

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

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

type AddDeclareTxnInput interface{}

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

type AddInvokeTransactionResponse struct {
	TransactionHash *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 BlockTransactions `json:"transactions"`
}

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

type BlockDeclareTxnV0 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeclareTxnV0
}

type BlockDeclareTxnV1 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeclareTxnV1
}

type BlockDeclareTxnV2 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeclareTxnV2
}

type BlockDeclareTxnV3 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeclareTxnV3
}

type BlockDeployAccountTxn struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeployAccountTxn
}

type BlockDeployTxn struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	DeployTxn
}

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

type BlockHeader struct {
	// BlockHash The hash of this block
	BlockHash *felt.Felt `json:"block_hash"`
	// ParentHash The hash of this block's parent
	ParentHash *felt.Felt `json:"parent_hash"`
	// BlockNumber the block number (its height)
	BlockNumber 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"`
	Tag    string     `json:"block_tag,omitempty"`
}

type BlockInvokeTxnV0 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	InvokeTxnV0
}

type BlockInvokeTxnV1 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	InvokeTxnV1
}

type BlockInvokeTxnV3 struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	InvokeTxnV3
}

type BlockL1HandlerTxn struct {
	TransactionHash *felt.Felt `json:"transaction_hash"`
	L1HandlerTxn
}

type BlockStatus string

type BlockTransaction struct {
	IBlockTransaction
}

type BlockTransactions []IBlockTransaction

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 struct {
	DeployAccountTxnV3
}

type BroadcastInvokeTxnV3 struct {
	InvokeTxnV3
}

type BroadcastTxn interface{}

type CallType string

type ClassOutput interface{}

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

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

type ContractExecutionError struct {
	// the error raised during execution
	Message              string                       `json:",omitempty"`
	ContractExecErrInner *ContractExecutionErrorInner `json:",omitempty"`
}

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{}

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 DeployAccountTxn 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 DeployAccountTxnTrace struct {
	ValidateInvocation *FnInvocation `json:"validate_invocation,omitempty"`
	//the trace of the __execute__ call or constructor call, depending on the transaction type (none for declare transactions)
	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 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{}

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 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 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"`
	// 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 {
	FromAddress *felt.Felt     `json:"from_address,omitempty"` // Optional. Filter events by from_address which emitted the event
	Keys        [][]*felt.Felt `json:"keys,omitempty"`         // Optional. Per key (by position), designate the possible values to be matched for events to be returned. Empty array designates 'any' value
	BlockID     BlockID        `json:"block_id,omitempty"`     // Optional. The block to get notifications from, default is latest, limited to 1024 blocks back
}

type EventsInput struct {
	EventFilter
	ResultPageRequest
}

type ExecInvocation struct {
	*FnInvocation
	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 {
	// 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"`

	// Units in which the fee is given
	FeeUnit FeePaymentUnit `json:"unit"`
}

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

type FeePaymentUnit string

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 IBlockTransaction interface {
	Hash() *felt.Felt
}

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 or constructor call, depending on the transaction type (none for declare transactions)
	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{}

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,omitempty"`
	// Version of the transaction scheme
	Version L1HandlerTxnVersion `json:"version"`
	// Nonce
	Nonce string `json:"nonce,omitempty"`
	FunctionCall
}

type L1HandlerTxnTrace struct {
	//the trace of the __execute__ call or constructor call, depending on the transaction type (none for declare transactions)
	FunctionInvocation FnInvocation       `json:"function_invocation"`
	StateDiff          *StateDiff         `json:"state_diff,omitempty"`
	ExecutionResources ExecutionResources `json:"execution_resources"`
	Type               TransactionType    `json:"type"`
}

type L1HandlerTxnVersion string

type MerkleNode struct {
	Type string
	Data any
}

type MessageStatusResp struct {
	// The hash of a L1 handler transaction
	TransactionHash *felt.Felt `json:"transaction_hash"`
	// The finality status of the transaction, including the case the txn is still in the mempool or failed validation during the block construction phase
	FinalityStatus TxnStatus `json:"finality_status"`
	// The failure reason, only appears if finality_status is REJECTED
	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 NewTxnStatusResp struct {
	TransactionHash *felt.Felt    `json:"transaction_hash"`
	Status          TxnStatusResp `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 PendingBlock struct {
	PendingBlockHeader
	BlockTransactions
}

type PendingBlockHeader struct {
	// ParentHash The hash of this block's parent
	ParentHash *felt.Felt `json:"parent_hash"`
	// 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 PendingBlockTxHashes struct {
	PendingBlockHeader
	Transactions []*felt.Felt `json:"transactions"`
}

type PendingBlockWithReceipts struct {
	PendingBlockHeader
	BlockBodyWithReceipts
}

type PendingStateUpdate struct {
	// OldRoot is the previous global state root.
	OldRoot *felt.Felt `json:"old_root"`
	// AcceptedTime is when the block was accepted on L1.
	StateDiff StateDiff `json:"state_diff"`
}

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) (*FeeEstimation, error)
	Events(ctx context.Context, input EventsInput) (*EventChunk, error)
	GetStorageProof(ctx context.Context, storageProofInput StorageProofInput) (*StorageProofResult, error)
	GetTransactionStatus(ctx context.Context, transactionHash *felt.Felt) (*TxnStatusResp, error)
	GetMessagesStatus(ctx context.Context, transactionHash NumAsHex) ([]MessageStatusResp, 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,
	BlockHash *felt.Felt `json:"block_hash"`
	// NewRoot is the new global state root.
	NewRoot *felt.Felt `json:"new_root"`
	// Pending
	PendingStateUpdate
}

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 SubPendingTxns struct {
	// The hash of the pending transaction. Always present.
	TransactionHash *felt.Felt
	// The full transaction details. Only present if transactionDetails is true.
	Transaction *BlockTransaction
}

type SubPendingTxnsInput struct {
	// Optional: Get all transaction details, and not only the hash. If not provided, only hash is returned. Default is false
	TransactionDetails bool `json:"transaction_details,omitempty"`
	// Optional: Filter transactions to only receive notification from address list
	SenderAddress []*felt.Felt `json:"sender_address,omitempty"`
}

type SyncStatus struct {
	SyncStatus        *bool
	StartingBlockHash *felt.Felt `json:"starting_block_hash,omitempty"`
	StartingBlockNum  NumAsHex   `json:"starting_block_num,omitempty"`
	CurrentBlockHash  *felt.Felt `json:"current_block_hash,omitempty"`
	CurrentBlockNum   NumAsHex   `json:"current_block_num,omitempty"`
	HighestBlockHash  *felt.Felt `json:"highest_block_hash,omitempty"`
	HighestBlockNum   NumAsHex   `json:"highest_block_num,omitempty"`
}

type TXN struct {
	Hash                  *felt.Felt            `json:"transaction_hash,omitempty"`
	Type                  TransactionType       `json:"type"`
	Version               *felt.Felt            `json:"version,omitempty"`
	Nonce                 *felt.Felt            `json:"nonce,omitempty"`
	MaxFee                *felt.Felt            `json:"max_fee,omitempty"`
	ContractAddress       *felt.Felt            `json:"contract_address,omitempty"`
	ContractAddressSalt   *felt.Felt            `json:"contract_address_salt,omitempty"`
	ClassHash             *felt.Felt            `json:"class_hash,omitempty"`
	ConstructorCalldata   []*felt.Felt          `json:"constructor_calldata,omitempty"`
	SenderAddress         *felt.Felt            `json:"sender_address,omitempty"`
	Signature             *[]*felt.Felt         `json:"signature,omitempty"`
	Calldata              *[]*felt.Felt         `json:"calldata,omitempty"`
	EntryPointSelector    *felt.Felt            `json:"entry_point_selector,omitempty"`
	CompiledClassHash     *felt.Felt            `json:"compiled_class_hash,omitempty"`
	ResourceBounds        ResourceBoundsMapping `json:"resource_bounds"`
	Tip                   U64                   `json:"tip"`
	PayMasterData         []*felt.Felt          `json:"paymaster_data"`
	AccountDeploymentData []*felt.Felt          `json:"account_deployment_data"`
	NonceDataMode         DataAvailabilityMode  `json:"nonce_data_availability_mode"`
	FeeMode               DataAvailabilityMode  `json:"fee_data_availability_mode"`
}

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,omitempty"`
}

type Transaction interface {
	GetType() TransactionType
}

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

type TransactionReceipt struct {
	TransactionHash    *felt.Felt         `json:"transaction_hash"`
	ActualFee          FeePayment         `json:"actual_fee"`
	ExecutionStatus    TxnExecutionStatus `json:"execution_status"`
	FinalityStatus     TxnFinalityStatus  `json:"finality_status"`
	Type               TransactionType    `json:"type,omitempty"`
	MessagesSent       []MsgToL1          `json:"messages_sent"`
	RevertReason       string             `json:"revert_reason,omitempty"`
	Events             []Event            `json:"events"`
	ExecutionResources ExecutionResources `json:"execution_resources"`
	ContractAddress    *felt.Felt         `json:"contract_address,omitempty"`
	MessageHash        NumAsHex           `json:"message_hash,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
	TransactionHash *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 TxnStatusResp struct {
	FinalityStatus  TxnStatus          `json:"finality_status"`
	ExecutionStatus TxnExecutionStatus `json:"execution_status,omitempty"`
	FailureReason   string             `json:"failure_reason,omitempty"`
}

type TxnTrace interface{}

type U128 string

type U64 string

type UnknownTransaction struct{ Transaction }

type WebsocketProvider interface {
	SubscribeEvents(ctx context.Context, events chan<- *EmittedEvent, options *EventSubscriptionInput) (*client.ClientSubscription, error)
	SubscribeNewHeads(ctx context.Context, headers chan<- *BlockHeader, blockID BlockID) (*client.ClientSubscription, error)
	SubscribePendingTransactions(ctx context.Context, pendingTxns chan<- *SubPendingTxns, options *SubPendingTxnsInput) (*client.ClientSubscription, error)
	SubscribeTransactionStatus(ctx context.Context, newStatus chan<- *NewTxnStatusResp, transactionHash *felt.Felt) (*client.ClientSubscription, error)
}

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