crossdomain

package
v0.0.0-...-eb934a0 Latest Latest
Warning

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

 Go to latest Published: Aug 3, 2023 License: MIT Imports: 17 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	RelayConstantOverhead            uint64 = 200_000
	RelayPerByteDataCost             uint64 = params.TxDataNonZeroGasEIP2028
	MinGasDynamicOverheadNumerator   uint64 = 64
	MinGasDynamicOverheadDenominator uint64 = 63
	RelayCallOverhead                uint64 = 40_000
	RelayReservedGas                 uint64 = 40_000
	RelayGasCheckBuffer              uint64 = 5_000
)

Constants used by `CrossDomainMessenger.baseGas`

View Source 
var (
	// Standard ABI types
	Uint256Type, _ = abi.NewType("uint256", "", nil)
	BytesType, _   = abi.NewType("bytes", "", nil)
	AddressType, _ = abi.NewType("address", "", nil)
	Bytes32Type, _ = abi.NewType("bytes32", "", nil)
)
View Source 
var (
	SentMessageEventABI               = "SentMessage(address,address,bytes,uint256)"
	SentMessageEventABIHash           = crypto.Keccak256Hash([]byte(SentMessageEventABI))
	SentMessageExtension1EventABI     = "SentMessage(address,uint256)"
	SentMessageExtension1EventABIHash = crypto.Keccak256Hash([]byte(SentMessageExtension1EventABI))
	MessagePassedEventABI             = "MessagePassed(uint256,address,address,uint256,uint256,bytes,bytes32)"
	MessagePassedEventABIHash         = crypto.Keccak256Hash([]byte(MessagePassedEventABI))
)
View Source 
var (
	// NonceMask represents a mask used to extract version bytes from the nonce
	NonceMask, _ = new(big.Int).SetString("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)
)

Functions

func ApplyL1ToL2Alias 

func ApplyL1ToL2Alias(address common.Address) common.Address

ApplyL1ToL2Alias will apply the alias applied to L1 to L2 messages when it originates from a contract address

func DecodeVersionedNonce 

func DecodeVersionedNonce(versioned *big.Int) (*big.Int, *big.Int)

DecodeVersionedNonce will decode the version that is encoded in the nonce

func EncodeCrossDomainMessageV0 

func EncodeCrossDomainMessageV0(
	target common.Address,
	sender common.Address,
	message []byte,
	nonce *big.Int,
) ([]byte, error)

EncodeCrossDomainMessageV0 will encode the calldata for "relayMessage(address,address,bytes,uint256)",

func EncodeCrossDomainMessageV1 

func EncodeCrossDomainMessageV1(
	nonce *big.Int,
	sender common.Address,
	target common.Address,
	value *big.Int,
	gasLimit *big.Int,
	data []byte,
) ([]byte, error)

EncodeCrossDomainMessageV1 will encode the calldata for "relayMessage(uint256,address,address,uint256,uint256,bytes)",

func EncodeVersionedNonce 

func EncodeVersionedNonce(nonce, version *big.Int) *big.Int

EncodeVersionedNonce will encode the version into the nonce

func HashCrossDomainMessageV0 

func HashCrossDomainMessageV0(
	target common.Address,
	sender common.Address,
	data []byte,
	nonce *big.Int,
) (common.Hash, error)

HashCrossDomainMessageV0 computes the pre bedrock cross domain messaging hashing scheme.

func HashCrossDomainMessageV1 

func HashCrossDomainMessageV1(
	nonce *big.Int,
	sender common.Address,
	target common.Address,
	value *big.Int,
	gasLimit *big.Int,
	data []byte,
) (common.Hash, error)

HashCrossDomainMessageV1 computes the first post bedrock cross domain messaging hashing scheme.

func MigrateWithdrawalGasLimit 

func MigrateWithdrawalGasLimit(data []byte, chainID *big.Int) uint64

MigrateWithdrawalGasLimit computes the gas limit for the migrated withdrawal. The chain id is used to determine the overhead.

func UndoL1ToL2Alias 

func UndoL1ToL2Alias(address common.Address) common.Address

UndoL1ToL2Alias will remove the alias applied to L1 to L2 messages when it originates from a contract address

Types

type CrossDomainMessage 

type CrossDomainMessage struct {
	Nonce    *big.Int       `json:"nonce"`
	Sender   common.Address `json:"sender"`
	Target   common.Address `json:"target"`
	Value    *big.Int       `json:"value"`
	GasLimit *big.Int       `json:"gasLimit"`
	Data     []byte         `json:"data"`
}

CrossDomainMessage represents a cross domain message used by the CrossDomainMessenger. The version is encoded in the nonce. Version 0 messages do not have a value, version 1 messages have a value and the most significant byte of the nonce is a 1

func NewCrossDomainMessage 

func NewCrossDomainMessage(
	nonce *big.Int,
	sender, target common.Address,
	value, gasLimit *big.Int,
	data []byte,
) *CrossDomainMessage

NewCrossDomainMessage creates a CrossDomainMessage.

func (*CrossDomainMessage) Encode 

func (c *CrossDomainMessage) Encode() ([]byte, error)

Encode will encode a cross domain message based on the version.

func (*CrossDomainMessage) Hash 

func (c *CrossDomainMessage) Hash() (common.Hash, error)

Hash will compute the hash of the CrossDomainMessage

func (*CrossDomainMessage) HashV1 

func (c *CrossDomainMessage) HashV1() (common.Hash, error)

HashV1 forces using the V1 hash even if its a legacy hash. This is used for the migration process.

func (*CrossDomainMessage) Version 

func (c *CrossDomainMessage) Version() uint64

Version will return the version of the CrossDomainMessage. It does this by looking at the first byte of the nonce.

type LegacyReceipt 

type LegacyReceipt struct {
	// Consensus fields: These fields are defined by the Yellow Paper
	PostState         []byte       `json:"root"`
	Status            uint64       `json:"status"`
	CumulativeGasUsed uint64       `json:"cumulativeGasUsed" gencodec:"required"`
	Bloom             types.Bloom  `json:"logsBloom"         gencodec:"required"`
	Logs              []*types.Log `json:"logs"              gencodec:"required"`

	// Implementation fields: These fields are added by geth when processing a transaction.
	// They are stored in the chain database.
	TxHash          common.Hash    `json:"transactionHash" gencodec:"required"`
	ContractAddress common.Address `json:"contractAddress"`
	GasUsed         uint64         `json:"gasUsed" gencodec:"required"`

	// Inclusion information: These fields provide information about the inclusion of the
	// transaction corresponding to this receipt.
	BlockHash        common.Hash `json:"blockHash,omitempty"`
	BlockNumber      *big.Int    `json:"blockNumber,omitempty"`
	TransactionIndex uint        `json:"transactionIndex"`

	// UsingOVM
	L1GasPrice *big.Int   `json:"l1GasPrice" gencodec:"required"`
	L1GasUsed  *big.Int   `json:"l1GasUsed" gencodec:"required"`
	L1Fee      *big.Int   `json:"l1Fee" gencodec:"required"`
	FeeScalar  *big.Float `json:"l1FeeScalar" gencodec:"required"`
}

func ReadLegacyReceipts 

func ReadLegacyReceipts(db ethdb.Reader, hash common.Hash, number uint64) ([]*LegacyReceipt, error)

func (*LegacyReceipt) DecodeRLP 

func (r *LegacyReceipt) DecodeRLP(s *rlp.Stream) error

DecodeRLP implements rlp.Decoder, and loads both consensus and implementation fields of a receipt from an RLP stream.

type LegacyWithdrawal 

type LegacyWithdrawal struct {
	// MessageSender is the caller of the message passer
	MessageSender common.Address `json:"who"`
	// XDomainTarget is the L1 target of the withdrawal message
	XDomainTarget common.Address `json:"target"`
	// XDomainSender is the L2 withdrawing account
	XDomainSender common.Address `json:"sender"`
	// XDomainData represents the calldata of the withdrawal message
	XDomainData hexutil.Bytes `json:"data"`
	// XDomainNonce represents the nonce of the withdrawal
	XDomainNonce *big.Int `json:"nonce"`
}

LegacyWithdrawal represents a pre bedrock upgrade withdrawal.

func NewLegacyWithdrawal 

func NewLegacyWithdrawal(msgSender, target, sender common.Address, data []byte, nonce *big.Int) *LegacyWithdrawal

NewLegacyWithdrawal will construct a LegacyWithdrawal

func (*LegacyWithdrawal) CrossDomainMessage 

func (w *LegacyWithdrawal) CrossDomainMessage() *CrossDomainMessage

CrossDomainMessage turns the LegacyWithdrawal into a CrossDomainMessage. LegacyWithdrawals do not have the concept of value or gaslimit, so set them to 0.

func (*LegacyWithdrawal) Decode 

func (w *LegacyWithdrawal) Decode(data []byte) error

Decode will decode a serialized LegacyWithdrawal. There is a known inconsistency where the decoded `msg.sender` is not authenticated. A round trip of encoding and decoding with a spoofed withdrawal will result in a different message being recovered.

func (*LegacyWithdrawal) Encode 

func (w *LegacyWithdrawal) Encode() ([]byte, error)

Encode will serialze the Withdrawal in the legacy format so that it is suitable for hashing. This assumes that the message is being withdrawn through the standard slice cross domain messaging system by hashing in the L2CrossDomainMessenger address.

func (*LegacyWithdrawal) Hash 

func (w *LegacyWithdrawal) Hash() (common.Hash, error)

Hash will compute the legacy style hash that is computed in the OVM_L2ToL1MessagePasser.

func (*LegacyWithdrawal) StorageSlot 

func (w *LegacyWithdrawal) StorageSlot() (common.Hash, error)

StorageSlot will compute the storage slot that is set to true in the legacy L2ToL1MessagePasser.

func (*LegacyWithdrawal) Value 

func (w *LegacyWithdrawal) Value() (*big.Int, error)

Value returns the ETH value associated with the withdrawal. Since ETH was represented as an ERC20 token before the Bedrock upgrade, the sender and calldata must be observed and the value must be parsed out if "finalizeETHWithdrawal" is the method.

type Withdrawal 

type Withdrawal struct {
	Nonce    *big.Int        `json:"nonce"`
	Sender   *common.Address `json:"sender"`
	Target   *common.Address `json:"target"`
	Value    *big.Int        `json:"value"`
	GasLimit *big.Int        `json:"gasLimit"`
	Data     hexutil.Bytes   `json:"data"`
}

Withdrawal represents a withdrawal transaction on L2

func MigrateWithdrawal 

func MigrateWithdrawal(
	withdrawal *LegacyWithdrawal,
	l1CrossDomainMessenger *common.Address,
	chainID *big.Int,
) (*Withdrawal, error)

MigrateWithdrawal will turn a LegacyWithdrawal into a bedrock style Withdrawal.

func NewWithdrawal 

func NewWithdrawal(
	nonce *big.Int,
	sender, target *common.Address,
	value, gasLimit *big.Int,
	data []byte,
) *Withdrawal

NewWithdrawal will create a Withdrawal

func (*Withdrawal) Decode 

func (w *Withdrawal) Decode(data []byte) error

Decode will deserialize a Withdrawal

func (*Withdrawal) Encode 

func (w *Withdrawal) Encode() ([]byte, error)

Encode will serialize the Withdrawal so that it is suitable for hashing.

func (*Withdrawal) Hash 

func (w *Withdrawal) Hash() (common.Hash, error)

Hash will hash the Withdrawal. This is the hash that is computed in the L2ToL1MessagePasser. The encoding is the same as the v1 cross domain message encoding without the 4byte selector prepended.

func (*Withdrawal) StorageSlot 

func (w *Withdrawal) StorageSlot() (common.Hash, error)

StorageSlot will compute the storage slot that will be set to true in the L2ToL1MessagePasser. The withdrawal proof sent to L1 will prove that this storage slot is set to "true".

func (*Withdrawal) WithdrawalTransaction 

func (w *Withdrawal) WithdrawalTransaction() bindings.TypesWithdrawalTransaction

WithdrawalTransaction will convert the Withdrawal to a type suitable for sending a transaction.

type WithdrawalMessage 

type WithdrawalMessage interface {
	Encode() ([]byte, error)
	Decode([]byte) error
	Hash() (common.Hash, error)
	StorageSlot() (common.Hash, error)
}

WithdrawalMessage represents a Withdrawal. The Withdrawal and LegacyWithdrawal types must implement this interface.

Source Files

View all Source files

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.