athena_abi

type AbiEvent ¶

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

func NewAbiEvent(name string, parameters []string, data map[string]StarknetType, keys interface{}, abiName interface{}) *AbiEvent

func ParseAbiEvent(abiEvent map[string]interface{}, customTypes map[string]interface{}) (*AbiEvent, error)

func (ae AbiEvent) Decode(data []*big.Int, keys []*big.Int) (*DecodedEvent, error)

type AbiFunction ¶

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

class Representing an ABI Function. Includes a function name, the function signature, and the input and output parameters.

func NewAbiFunction(name string, inputs []AbiParameter, outputs []StarknetType, abiName string) *AbiFunction

func ParseAbiFunction(abiFunction map[string]interface{}, customTypes map[string]interface{}) (*AbiFunction, error)

func (af *AbiFunction) Decode(callData []*big.Int, result interface{}) (*DecodedFunction, error)

func (af *AbiFunction) Encode(inputs map[string]interface{}) []*big.Int

type AbiInterface ¶

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

class Representing an ABI Interface. Includes a name and a list of functions.

type AbiMemberType ¶

type AbiMemberType string

const (
	Function    AbiMemberType = "function"
	L1Handler   AbiMemberType = "l1_handler"
	AbiStruct   AbiMemberType = "struct"
	Constructor AbiMemberType = "constructor"
	Event       AbiMemberType = "event"
	Interface   AbiMemberType = "interface"
	Impl        AbiMemberType = "impl"
	TypeDef     AbiMemberType = "type_def" // Internal Definition: typeDef = Union[struct, enum]
)

type AbiParameter ¶

type AbiParameter struct {
	Name string
	Type StarknetType
}

type DecodedEvent ¶

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

class representing the result of decoding an ABI Event

type DecodedFunction ¶

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

class representing the result of decoding an ABI

type DispatcherDecodeError ¶

type DispatcherDecodeError struct {
	Msg string
}

DispatcherDecodeError is raised when there is an error decoding Functions, Events, or User Operations using the decoding dispatcher.

func (e *DispatcherDecodeError) Error() string

type InvalidAbiError ¶

type InvalidAbiError struct {
	Msg string
}

InvalidAbiError is raised when malformed ABI JSON is supplied to the parser.

func (e *InvalidAbiError) Error() string

type InvalidCalldataError ¶

type InvalidCalldataError struct {
	Msg string
}

InvalidCalldataError is raised when there is not enough calldata to decode the type.

func (e *InvalidCalldataError) Error() string

type StarknetABI ¶

type StarknetABI struct {
	ABIName               *string
	ClassHash             []byte
	Functions             map[string]AbiFunction
	Events                map[string]AbiEvent
	Constructor           []AbiParameter
	L1Handler             *AbiFunction
	ImplementedInterfaces map[string]AbiInterface
}

func StarknetAbiFromJSON(abiJson []map[string]interface{}, abiName string, classHash []byte) (*StarknetABI, error)

type StarknetAbiEventKind ¶

type StarknetAbiEventKind string

const (
	Enum   StarknetAbiEventKind = "enum"
	Struct StarknetAbiEventKind = "struct"
	Data   StarknetAbiEventKind = "data"
	Nested StarknetAbiEventKind = "nested"
	Key    StarknetAbiEventKind = "key"
	Flat   StarknetAbiEventKind = "flat"
)

type StarknetArray ¶

type StarknetArray struct {
	InnerType StarknetType
}

Dataclass representing a Starknet ABI Array. Both core::array::Array and core::array::Span are mapped to this dataclass since their ABI Encoding & Decoding are identical

type StarknetCoreType ¶

type StarknetCoreType int

const (
	U8   StarknetCoreType = 1
	U16  StarknetCoreType = 2
	U32  StarknetCoreType = 4
	U64  StarknetCoreType = 8
	U128 StarknetCoreType = 16
	U256 StarknetCoreType = 32
	// Random Enum values for the rest
	Bool            StarknetCoreType = 3
	Felt            StarknetCoreType = 5
	ContractAddress StarknetCoreType = 6
	EthAddress      StarknetCoreType = 7
	ClassHash       StarknetCoreType = 9
	StorageAddress  StarknetCoreType = 10
	Bytes31         StarknetCoreType = 11
	NoneType        StarknetCoreType = 12
)

func (t StarknetCoreType) String() string

type StarknetEnum ¶

type StarknetEnum struct {
	Name     string
	Variants []struct {
		Name string
		Type StarknetType
	}
}

type StarknetNonZero ¶

type StarknetNonZero struct {
	InnerType StarknetType
}

type StarknetOption ¶

type StarknetOption struct {
	InnerType StarknetType
}

type StarknetStruct ¶

type StarknetStruct struct {
	Name    string
	Members []AbiParameter
}

type StarknetTuple ¶

type StarknetTuple struct {
	Members []StarknetType
}

func ParseTuple(abiType string, customTypes map[string]interface{}) (StarknetTuple, error)

type StarknetType ¶

type StarknetType interface {
	// contains filtered or unexported methods
}

func GetEnumIndex(enumType StarknetEnum, enumKey string) (int, StarknetType, error)

func ParseAbiTypes(types []string, customTypes map[string]interface{}) ([]StarknetType, error)

type TypeDecodeError ¶

type TypeDecodeError struct {
	Msg string
}

TypeDecodeError is raised when a type cannot be decoded from the calldata.

func (e *TypeDecodeError) Error() string

type TypeEncodeError ¶

type TypeEncodeError struct {
	Msg string
}

TypeEncodeError is raised when a type cannot be encoded from the calldata.

func (e *TypeEncodeError) Error() string