core

package
v0.2.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2023 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrContractNotDeployed     = errors.New("contract not deployed")
	ErrContractAlreadyDeployed = errors.New("contract already deployed")
)

Functions

func ContractAddress 

func ContractAddress(callerAddress, classHash, salt *felt.Felt, constructorCallData []*felt.Felt) *felt.Felt

ContractAddress computes the address of a Starknet contract.

func VerifyBlockHash 

func VerifyBlockHash(b *Block, network utils.Network) error

VerifyBlockHash verifies the block hash. Due to bugs in Starknet alpha, not all blocks have verifiable hashes.

func VerifyClassHashes added in v0.2.1 

func VerifyClassHashes(classes map[felt.Felt]Class) error

func VerifyTransactions added in v0.2.1 

func VerifyTransactions(txs []Transaction, n utils.Network) error

Types

type Block 

type Block struct {
	*Header
	Transactions []Transaction
	Receipts     []*TransactionReceipt
}

type BuiltinInstanceCounter 

type BuiltinInstanceCounter struct {
	Bitwise    uint64
	EcOp       uint64
	Ecsda      uint64
	Output     uint64
	Pedersen   uint64
	RangeCheck uint64
}

type Cairo0Class added in v0.2.1 

type Cairo0Class struct {
	Abi any
	// External functions defined in the class.
	Externals []EntryPoint
	// Functions that receive L1 messages. See
	// https://www.cairo-lang.org/docs/hello_starknet/l1l2.html#receiving-a-message-from-l1
	L1Handlers []EntryPoint
	// Constructors for the class. Currently, only one is allowed.
	Constructors []EntryPoint
	// An ascii-encoded array of builtin names imported by the class.
	Builtins []*felt.Felt
	// The starknet_keccak hash of the ".json" file compiler output.
	ProgramHash *felt.Felt
	Bytecode    []*felt.Felt
}

Cairo0Class unambiguously defines a Contract's semantics.

func (*Cairo0Class) Hash added in v0.2.1 

func (c *Cairo0Class) Hash() *felt.Felt

func (*Cairo0Class) Version added in v0.2.1 

func (c *Cairo0Class) Version() uint64

type Cairo1Class added in v0.2.1 

type Cairo1Class struct {
	Abi         string
	AbiHash     *felt.Felt
	EntryPoints struct {
		Constructor []SierraEntryPoint
		External    []SierraEntryPoint
		L1Handler   []SierraEntryPoint
	}
	Program         []*felt.Felt
	ProgramHash     *felt.Felt
	SemanticVersion string
}

Cairo1Class unambiguously defines a Contract's semantics.

func (*Cairo1Class) Hash added in v0.2.1 

func (c *Cairo1Class) Hash() *felt.Felt

func (*Cairo1Class) Version added in v0.2.1 

func (c *Cairo1Class) Version() uint64

type CantVerifyClassHashError added in v0.2.1 

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

func (CantVerifyClassHashError) Class added in v0.2.1 

func (e CantVerifyClassHashError) Class() Class

func (CantVerifyClassHashError) Error added in v0.2.1 

func (e CantVerifyClassHashError) Error() string

func (CantVerifyClassHashError) Unwrap added in v0.2.1 

func (e CantVerifyClassHashError) Unwrap() error

type CantVerifyTransactionHashError added in v0.2.1 

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

func (CantVerifyTransactionHashError) Error added in v0.2.1 

func (e CantVerifyTransactionHashError) Error() string

func (CantVerifyTransactionHashError) Hash added in v0.2.1 

func (e CantVerifyTransactionHashError) Hash() *felt.Felt

func (CantVerifyTransactionHashError) Unwrap added in v0.2.1 

func (e CantVerifyTransactionHashError) Unwrap() error

type Class 

type Class interface {
	Version() uint64
	Hash() *felt.Felt
}

Class unambiguously defines a Contract's semantics.

type Contract 

type Contract struct {
	// Address that this contract instance is deployed to
	Address *felt.Felt
	// contains filtered or unexported fields
}

Contract is an instance of a Class.

func DeployContract added in v0.2.1 

func DeployContract(addr, classHash *felt.Felt, txn db.Transaction) (*Contract, error)

DeployContract sets up the database for a new contract.

func NewContract 

func NewContract(addr *felt.Felt, txn db.Transaction) (*Contract, error)

NewContract creates a contract instance at the given address. Deploy should be called for contracts that were just deployed to the network.

func (*Contract) ClassHash 

func (c *Contract) ClassHash() (*felt.Felt, error)

ClassHash returns hash of the class that this contract instantiates.

func (*Contract) Nonce 

func (c *Contract) Nonce() (*felt.Felt, error)

Nonce returns the amount transactions sent from this contract. Only account contracts can have a non-zero nonce.

func (*Contract) Replace added in v0.2.1 

func (c *Contract) Replace(classHash *felt.Felt) error

Replace replaces the class that the contract instantiates

func (*Contract) Root added in v0.2.1 

func (c *Contract) Root() (*felt.Felt, error)

Root returns the root of the contract storage.

func (*Contract) Storage 

func (c *Contract) Storage(key *felt.Felt) (*felt.Felt, error)

func (*Contract) UpdateNonce 

func (c *Contract) UpdateNonce(nonce *felt.Felt) error

UpdateNonce updates the nonce value in the database.

func (*Contract) UpdateStorage 

func (c *Contract) UpdateStorage(diff []StorageDiff) error

UpdateStorage applies a change-set to the contract storage.

type DeclareTransaction 

type DeclareTransaction struct {
	TransactionHash *felt.Felt
	// The class hash
	ClassHash *felt.Felt
	// The address of the account initiating the transaction.
	SenderAddress *felt.Felt
	// The maximum fee that the sender is willing to pay for the transaction.
	MaxFee *felt.Felt
	// Additional information given by the sender, used to validate the transaction.
	TransactionSignature []*felt.Felt
	// The transaction nonce.
	Nonce *felt.Felt
	// The transaction’s version. Possible values are 1 or 0.
	// When the fields that comprise a transaction change,
	// either with the addition of a new field or the removal of an existing field,
	// then the transaction version increases.
	// Transaction version 0 is deprecated and will be removed in a future version of Starknet.
	Version *felt.Felt

	// Version 2 fields
	CompiledClassHash *felt.Felt
}

func (*DeclareTransaction) Hash 

func (d *DeclareTransaction) Hash() *felt.Felt

func (*DeclareTransaction) Signature 

func (d *DeclareTransaction) Signature() []*felt.Felt

type DeclaredV1Class added in v0.2.1 

type DeclaredV1Class struct {
	ClassHash         *felt.Felt
	CompiledClassHash *felt.Felt
}

type DeployAccountTransaction 

type DeployAccountTransaction struct {
	DeployTransaction
	// The maximum fee that the sender is willing to pay for the transaction.
	MaxFee *felt.Felt
	// Additional information given by the sender, used to validate the transaction.
	TransactionSignature []*felt.Felt
	// The transaction nonce.
	Nonce *felt.Felt
}

func (*DeployAccountTransaction) Hash 

func (d *DeployAccountTransaction) Hash() *felt.Felt

func (*DeployAccountTransaction) Signature 

func (d *DeployAccountTransaction) Signature() []*felt.Felt

type DeployTransaction 

type DeployTransaction struct {
	TransactionHash *felt.Felt
	// A random number used to distinguish between different instances of the contract.
	ContractAddressSalt *felt.Felt
	// The address of the contract.
	ContractAddress *felt.Felt
	// The hash of the class which defines the contract’s functionality.
	ClassHash *felt.Felt
	// The arguments passed to the constructor during deployment.
	ConstructorCallData []*felt.Felt
	// The transaction’s version. Possible values are 1 or 0.
	//
	// When the fields that comprise a transaction change,
	// either with the addition of a new field or the removal of an existing field,
	// then the transaction version increases.
	// Transaction version 0 is deprecated and will be removed in a future version of Starknet.
	Version *felt.Felt
}

func (*DeployTransaction) Hash 

func (d *DeployTransaction) Hash() *felt.Felt

func (*DeployTransaction) Signature 

func (d *DeployTransaction) Signature() []*felt.Felt

type DeployedContract 

type DeployedContract struct {
	Address   *felt.Felt
	ClassHash *felt.Felt
}

type EntryPoint 

type EntryPoint struct {
	// starknet_keccak hash of the function signature.
	Selector *felt.Felt
	// The offset of the instruction in the class's bytecode.
	Offset *felt.Felt
}

EntryPoint uniquely identifies a Cairo function to execute.

type Event 

type Event struct {
	Data []*felt.Felt
	From *felt.Felt
	Keys []*felt.Felt
}

type ExecutionResources 

type ExecutionResources struct {
	BuiltinInstanceCounter BuiltinInstanceCounter
	MemoryHoles            uint64
	Steps                  uint64
}
type Header struct {
	// The hash of this block
	Hash *felt.Felt
	// The hash of this block’s parent
	ParentHash *felt.Felt
	// The number (height) of this block
	Number uint64
	// The state commitment after this block
	GlobalStateRoot *felt.Felt
	// The Starknet address of the sequencer who created this block
	SequencerAddress *felt.Felt
	// The amount Transactions and Receipts stored in this block
	TransactionCount uint64
	// The amount of events stored in transaction receipts
	EventCount uint64
	// The time the sequencer created this block before executing transactions
	Timestamp uint64
	// The version of the Starknet protocol used when creating this block
	ProtocolVersion string
	// Extraneous data that might be useful for running transactions
	ExtraData *felt.Felt
}

type InvokeTransaction 

type InvokeTransaction struct {
	TransactionHash *felt.Felt
	// The arguments that are passed to the validated and execute functions.
	CallData []*felt.Felt
	// Additional information given by the sender, used to validate the transaction.
	TransactionSignature []*felt.Felt
	// The maximum fee that the sender is willing to pay for the transaction
	MaxFee *felt.Felt
	// The address of the contract invoked by this transaction.
	ContractAddress *felt.Felt
	// When the fields that comprise a transaction change,
	// either with the addition of a new field or the removal of an existing field,
	// then the transaction version increases.
	Version *felt.Felt

	// Version 0 fields
	// The encoding of the selector for the function invoked (the entry point in the contract)
	EntryPointSelector *felt.Felt

	// Version 1 fields
	// The transaction nonce.
	Nonce *felt.Felt
	// The address of the sender of this transaction
	SenderAddress *felt.Felt
}

func (*InvokeTransaction) Hash 

func (i *InvokeTransaction) Hash() *felt.Felt

func (*InvokeTransaction) Signature 

func (i *InvokeTransaction) Signature() []*felt.Felt

type L1HandlerTransaction 

type L1HandlerTransaction struct {
	TransactionHash *felt.Felt
	// The address of the contract.
	ContractAddress *felt.Felt
	// The encoding of the selector for the function invoked (the entry point in the contract)
	EntryPointSelector *felt.Felt
	// The transaction nonce.
	Nonce *felt.Felt
	// The arguments that are passed to the validated and execute functions.
	CallData []*felt.Felt
	// When the fields that comprise a transaction change,
	// either with the addition of a new field or the removal of an existing field,
	// then the transaction version increases.
	Version *felt.Felt
}

func (*L1HandlerTransaction) Hash 

func (l *L1HandlerTransaction) Hash() *felt.Felt

func (*L1HandlerTransaction) Signature 

func (l *L1HandlerTransaction) Signature() []*felt.Felt

type L1ToL2Message 

type L1ToL2Message struct {
	From     common.Address
	Nonce    *felt.Felt
	Payload  []*felt.Felt
	Selector *felt.Felt
	To       *felt.Felt
}

type L2ToL1Message 

type L2ToL1Message struct {
	From    *felt.Felt
	Payload []*felt.Felt
	To      common.Address
}

type ReplacedClass added in v0.2.1 

type ReplacedClass struct {
	Address   *felt.Felt
	ClassHash *felt.Felt
}

type SierraEntryPoint added in v0.2.1 

type SierraEntryPoint struct {
	Index    uint64
	Selector *felt.Felt
}

type State 

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

func NewState 

func NewState(txn db.Transaction) *State

func (*State) ContractClassHash added in v0.2.1 

func (s *State) ContractClassHash(addr *felt.Felt) (*felt.Felt, error)

ContractClassHash returns class hash of a contract at a given address.

func (*State) ContractNonce added in v0.2.1 

func (s *State) ContractNonce(addr *felt.Felt) (*felt.Felt, error)

ContractNonce returns nonce of a contract at a given address.

func (*State) Root 

func (s *State) Root() (*felt.Felt, error)

Root returns the state commitment.

func (*State) Update 

func (s *State) Update(update *StateUpdate, declaredClasses map[felt.Felt]Class) error

Update applies a StateUpdate to the State object. State is not updated if an error is encountered during the operation. If update's old or new root does not match the state's old or new roots, [ErrMismatchedRoot] is returned.

type StateDiff 

type StateDiff struct {
	StorageDiffs      map[felt.Felt][]StorageDiff
	Nonces            map[felt.Felt]*felt.Felt
	DeployedContracts []DeployedContract
	DeclaredV0Classes []*felt.Felt
	DeclaredV1Classes []DeclaredV1Class
	ReplacedClasses   []ReplacedClass
}

type StateUpdate 

type StateUpdate struct {
	BlockHash *felt.Felt
	NewRoot   *felt.Felt
	OldRoot   *felt.Felt
	StateDiff *StateDiff
}

type StorageDiff 

type StorageDiff struct {
	Key   *felt.Felt
	Value *felt.Felt
}

type Transaction 

type Transaction interface {
	Hash() *felt.Felt
	Signature() []*felt.Felt
}

type TransactionReceipt 

type TransactionReceipt struct {
	Fee                *felt.Felt
	Events             []*Event
	ExecutionResources *ExecutionResources
	L1ToL2Message      *L1ToL2Message
	L2ToL1Message      []*L2ToL1Message
	TransactionHash    *felt.Felt
}

type TransactionStorage 

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

TransactionStorage is a database transaction on a trie.

func NewTransactionStorage 

func NewTransactionStorage(txn db.Transaction, prefix []byte) *TransactionStorage

func (*TransactionStorage) Delete 

func (t *TransactionStorage) Delete(key *bitset.BitSet) error

func (*TransactionStorage) Get 

func (t *TransactionStorage) Get(key *bitset.BitSet) (*trie.Node, error)

func (*TransactionStorage) Put 

func (t *TransactionStorage) Put(key *bitset.BitSet, value *trie.Node) error

Source Files

View all Source files

Directories

Path Synopsis
Package trie implements a dense Merkle Patricia Trie.
 Package trie implements a dense Merkle Patricia Trie.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.