withdrawals

Documentation

Index

• Variables
• func FindLatestGame(ctx context.Context, ...) (*bindings.IDisputeGameFactoryGameSearchResult, error)
• func GenerateProofDB(proof []string) *proofDB
• func ParseMessagePassed(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMessagePassed, error)
• func StorageSlotOfWithdrawalHash(hash common.Hash) common.Hash
• func VerifyAccountProof(root common.Hash, address common.Address, account types.StateAccount, ...) error
• func VerifyProof(stateRoot common.Hash, proof *gethclient.AccountResult) error
• func VerifyStorageProof(root common.Hash, proof gethclient.StorageResult) error
• func WithdrawalHash(ev *bindings.L2ToL1MessagePasserMessagePassed) (common.Hash, error)
• type BlockClient
• type ProofClient
• type ProvenWithdrawalParameters
  • func ProveWithdrawalParameters(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, ...) (ProvenWithdrawalParameters, error)
  • func ProveWithdrawalParametersFaultProofs(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, ...) (ProvenWithdrawalParameters, error)
  • func ProveWithdrawalParametersForBlock(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, ...) (ProvenWithdrawalParameters, error)
• type ReceiptClient

Variables

var (
	Uint256Type, _ = abi.NewType("uint256", "", nil)
	BytesType, _   = abi.NewType("bytes", "", nil)
	AddressType, _ = abi.NewType("address", "", nil)
)

Standard ABI types copied from golang ABI tests

var MessagePassedTopic = crypto.Keccak256Hash([]byte("MessagePassed(uint256,address,address,uint256,uint256,bytes,bytes32)"))

Functions

func FindLatestGame

func FindLatestGame(ctx context.Context, disputeGameFactoryContract *bindings.DisputeGameFactoryCaller, optimismPortal2Contract *bindingspreview.OptimismPortal2Caller) (*bindings.IDisputeGameFactoryGameSearchResult, error)

FindLatestGame finds the latest game in the DisputeGameFactory contract.

func GenerateProofDB

func GenerateProofDB(proof []string) *proofDB

func ParseMessagePassed

func ParseMessagePassed(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMessagePassed, error)

ParseMessagePassed parses MessagePassed events from a transaction receipt. It does not support multiple withdrawals per receipt.

func StorageSlotOfWithdrawalHash

func StorageSlotOfWithdrawalHash(hash common.Hash) common.Hash

StorageSlotOfWithdrawalHash determines the storage slot of the L2ToL1MessagePasser contract to look at given a WithdrawalHash

func VerifyAccountProof

func VerifyAccountProof(root common.Hash, address common.Address, account types.StateAccount, proof []string) error

func VerifyProof

func VerifyProof(stateRoot common.Hash, proof *gethclient.AccountResult) error

func VerifyStorageProof

func VerifyStorageProof(root common.Hash, proof gethclient.StorageResult) error

func WithdrawalHash

func WithdrawalHash(ev *bindings.L2ToL1MessagePasserMessagePassed) (common.Hash, error)

WithdrawalHash computes the hash of the withdrawal that was stored in the L2toL1MessagePasser contract state. TODO:

• I don't like having to use the ABI Generated struct
• There should be a better way to run the ABI encoding
• These needs to be fuzzed against the solidity

Types

type BlockClient

type BlockClient interface {
	BlockByNumber(context.Context, *big.Int) (*types.Block, error)
}

type ProofClient

type ProofClient interface {
	GetProof(context.Context, common.Address, []string, *big.Int) (*gethclient.AccountResult, error)
}

type ProvenWithdrawalParameters

type ProvenWithdrawalParameters struct {
	Nonce           *big.Int
	Sender          common.Address
	Target          common.Address
	Value           *big.Int
	GasLimit        *big.Int
	L2OutputIndex   *big.Int
	Data            []byte
	OutputRootProof bindings.TypesOutputRootProof
	WithdrawalProof [][]byte // List of trie nodes to prove L2 storage
}

ProvenWithdrawalParameters is the set of parameters to pass to the ProveWithdrawalTransaction and FinalizeWithdrawalTransaction functions

func ProveWithdrawalParameters

func ProveWithdrawalParameters(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, l2BlockCl BlockClient, txHash common.Hash, header *types.Header, l2OutputOracleContract *bindings.L2OutputOracleCaller) (ProvenWithdrawalParameters, error)

ProveWithdrawalParameters calls ProveWithdrawalParametersForBlock with the most recent L2 output after the given header.

func ProveWithdrawalParametersFaultProofs

func ProveWithdrawalParametersFaultProofs(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, l2BlockCl BlockClient, txHash common.Hash, disputeGameFactoryContract *bindings.DisputeGameFactoryCaller, optimismPortal2Contract *bindingspreview.OptimismPortal2Caller) (ProvenWithdrawalParameters, error)

ProveWithdrawalParametersFaultProofs calls ProveWithdrawalParametersForBlock with the most recent L2 output after the latest game.

func ProveWithdrawalParametersForBlock

func ProveWithdrawalParametersForBlock(ctx context.Context, proofCl ProofClient, l2ReceiptCl ReceiptClient, l2BlockCl BlockClient, txHash common.Hash, l2BlockNumber, l2OutputIndex *big.Int) (ProvenWithdrawalParameters, error)

ProveWithdrawalParametersForBlock queries L1 & L2 to generate all withdrawal parameters and proof necessary to prove a withdrawal on L1. The header provided is very important. It should be a block (timestamp) for which there is a submitted output in the L2 Output Oracle contract. If not, the withdrawal will fail as it the storage proof cannot be verified if there is no submitted state root.

type ReceiptClient

type ReceiptClient interface {
	TransactionReceipt(context.Context, common.Hash) (*types.Receipt, error)
}