style(ctb): remove Lib_ and OVM_ prefixes (#2923)

Removes Lib_ and OVM_ prefixes from all contracts. We're no longer using
prefixes for new contracts, I see no good reason to include prefixes for
all of the older contracts that are being included and overhauled as
part of this upgrade. Keeps everything consistent while also removing
some legacy cruft.

.changeset/violet-rules-know.md

+---
+'@eth-optimism/contracts-bedrock': minor
+---
+
+Remove Lib* and OVM* prefixes from all contracts

op-bindings/Makefile

@@ -33,7 +33,7 @@ gas-price-oracle-bindings:
 	./gen_bindings.sh GasPriceOracle bindings
 
 address-manager-bindings:
-	./gen_bindings.sh Lib_AddressManager bindings
+	./gen_bindings.sh AddressManager bindings
 
 mkdir:
 	mkdir -p bin bindings

op-bindings/bindings/lib_addressmanager.go → op-bindings/bindings/addressmanager.go

@@ -28,23 +28,23 @@ var (
 	_ = event.NewSubscription
 )
 
-// LibAddressManagerMetaData contains all meta data concerning the LibAddressManager contract.
-var LibAddressManagerMetaData = &bind.MetaData{
+// AddressManagerMetaData contains all meta data concerning the AddressManager contract.
+var AddressManagerMetaData = &bind.MetaData{
 	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_newAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_oldAddress\",\"type\":\"address\"}],\"name\":\"AddressSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"}],\"name\":\"getAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
 	Bin: "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",
 }
 
-// LibAddressManagerABI is the input ABI used to generate the binding from.
-// Deprecated: Use LibAddressManagerMetaData.ABI instead.
-var LibAddressManagerABI = LibAddressManagerMetaData.ABI
+// AddressManagerABI is the input ABI used to generate the binding from.
+// Deprecated: Use AddressManagerMetaData.ABI instead.
+var AddressManagerABI = AddressManagerMetaData.ABI
 
-// LibAddressManagerBin is the compiled bytecode used for deploying new contracts.
-// Deprecated: Use LibAddressManagerMetaData.Bin instead.
-var LibAddressManagerBin = LibAddressManagerMetaData.Bin
+// AddressManagerBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use AddressManagerMetaData.Bin instead.
+var AddressManagerBin = AddressManagerMetaData.Bin
 
-// DeployLibAddressManager deploys a new Ethereum contract, binding an instance of LibAddressManager to it.
-func DeployLibAddressManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LibAddressManager, error) {
-	parsed, err := LibAddressManagerMetaData.GetAbi()
+// DeployAddressManager deploys a new Ethereum contract, binding an instance of AddressManager to it.
+func DeployAddressManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AddressManager, error) {
+	parsed, err := AddressManagerMetaData.GetAbi()
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
@@ -52,111 +52,111 @@ func DeployLibAddressManager(auth *bind.TransactOpts, backend bind.ContractBacke
 		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
 	}
 
-	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(LibAddressManagerBin), backend)
+	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(AddressManagerBin), backend)
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
-	return address, tx, &LibAddressManager{LibAddressManagerCaller: LibAddressManagerCaller{contract: contract}, LibAddressManagerTransactor: LibAddressManagerTransactor{contract: contract}, LibAddressManagerFilterer: LibAddressManagerFilterer{contract: contract}}, nil
+	return address, tx, &AddressManager{AddressManagerCaller: AddressManagerCaller{contract: contract}, AddressManagerTransactor: AddressManagerTransactor{contract: contract}, AddressManagerFilterer: AddressManagerFilterer{contract: contract}}, nil
 }
 
-// LibAddressManager is an auto generated Go binding around an Ethereum contract.
-type LibAddressManager struct {
-	LibAddressManagerCaller     // Read-only binding to the contract
-	LibAddressManagerTransactor // Write-only binding to the contract
-	LibAddressManagerFilterer   // Log filterer for contract events
+// AddressManager is an auto generated Go binding around an Ethereum contract.
+type AddressManager struct {
+	AddressManagerCaller     // Read-only binding to the contract
+	AddressManagerTransactor // Write-only binding to the contract
+	AddressManagerFilterer   // Log filterer for contract events
 }
 
-// LibAddressManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
-type LibAddressManagerCaller struct {
+// AddressManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type AddressManagerCaller struct {
 	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 }
 
-// LibAddressManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type LibAddressManagerTransactor struct {
+// AddressManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type AddressManagerTransactor struct {
 	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 }
 
-// LibAddressManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
-type LibAddressManagerFilterer struct {
+// AddressManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type AddressManagerFilterer struct {
 	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 }
 
-// LibAddressManagerSession is an auto generated Go binding around an Ethereum contract,
+// AddressManagerSession is an auto generated Go binding around an Ethereum contract,
 // with pre-set call and transact options.
-type LibAddressManagerSession struct {
-	Contract     *LibAddressManager // Generic contract binding to set the session for
+type AddressManagerSession struct {
+	Contract     *AddressManager   // Generic contract binding to set the session for
 	CallOpts     bind.CallOpts     // Call options to use throughout this session
 	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 }
 
-// LibAddressManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// AddressManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 // with pre-set call options.
-type LibAddressManagerCallerSession struct {
-	Contract *LibAddressManagerCaller // Generic contract caller binding to set the session for
+type AddressManagerCallerSession struct {
+	Contract *AddressManagerCaller // Generic contract caller binding to set the session for
 	CallOpts bind.CallOpts         // Call options to use throughout this session
 }
 
-// LibAddressManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// AddressManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 // with pre-set transact options.
-type LibAddressManagerTransactorSession struct {
-	Contract     *LibAddressManagerTransactor // Generic contract transactor binding to set the session for
+type AddressManagerTransactorSession struct {
+	Contract     *AddressManagerTransactor // Generic contract transactor binding to set the session for
 	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
 }
 
-// LibAddressManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
-type LibAddressManagerRaw struct {
-	Contract *LibAddressManager // Generic contract binding to access the raw methods on
+// AddressManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type AddressManagerRaw struct {
+	Contract *AddressManager // Generic contract binding to access the raw methods on
 }
 
-// LibAddressManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type LibAddressManagerCallerRaw struct {
-	Contract *LibAddressManagerCaller // Generic read-only contract binding to access the raw methods on
+// AddressManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type AddressManagerCallerRaw struct {
+	Contract *AddressManagerCaller // Generic read-only contract binding to access the raw methods on
 }
 
-// LibAddressManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type LibAddressManagerTransactorRaw struct {
-	Contract *LibAddressManagerTransactor // Generic write-only contract binding to access the raw methods on
+// AddressManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type AddressManagerTransactorRaw struct {
+	Contract *AddressManagerTransactor // Generic write-only contract binding to access the raw methods on
 }
 
-// NewLibAddressManager creates a new instance of LibAddressManager, bound to a specific deployed contract.
-func NewLibAddressManager(address common.Address, backend bind.ContractBackend) (*LibAddressManager, error) {
-	contract, err := bindLibAddressManager(address, backend, backend, backend)
+// NewAddressManager creates a new instance of AddressManager, bound to a specific deployed contract.
+func NewAddressManager(address common.Address, backend bind.ContractBackend) (*AddressManager, error) {
+	contract, err := bindAddressManager(address, backend, backend, backend)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManager{LibAddressManagerCaller: LibAddressManagerCaller{contract: contract}, LibAddressManagerTransactor: LibAddressManagerTransactor{contract: contract}, LibAddressManagerFilterer: LibAddressManagerFilterer{contract: contract}}, nil
+	return &AddressManager{AddressManagerCaller: AddressManagerCaller{contract: contract}, AddressManagerTransactor: AddressManagerTransactor{contract: contract}, AddressManagerFilterer: AddressManagerFilterer{contract: contract}}, nil
 }
 
-// NewLibAddressManagerCaller creates a new read-only instance of LibAddressManager, bound to a specific deployed contract.
-func NewLibAddressManagerCaller(address common.Address, caller bind.ContractCaller) (*LibAddressManagerCaller, error) {
-	contract, err := bindLibAddressManager(address, caller, nil, nil)
+// NewAddressManagerCaller creates a new read-only instance of AddressManager, bound to a specific deployed contract.
+func NewAddressManagerCaller(address common.Address, caller bind.ContractCaller) (*AddressManagerCaller, error) {
+	contract, err := bindAddressManager(address, caller, nil, nil)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManagerCaller{contract: contract}, nil
+	return &AddressManagerCaller{contract: contract}, nil
 }
 
-// NewLibAddressManagerTransactor creates a new write-only instance of LibAddressManager, bound to a specific deployed contract.
-func NewLibAddressManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*LibAddressManagerTransactor, error) {
-	contract, err := bindLibAddressManager(address, nil, transactor, nil)
+// NewAddressManagerTransactor creates a new write-only instance of AddressManager, bound to a specific deployed contract.
+func NewAddressManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressManagerTransactor, error) {
+	contract, err := bindAddressManager(address, nil, transactor, nil)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManagerTransactor{contract: contract}, nil
+	return &AddressManagerTransactor{contract: contract}, nil
 }
 
-// NewLibAddressManagerFilterer creates a new log filterer instance of LibAddressManager, bound to a specific deployed contract.
-func NewLibAddressManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*LibAddressManagerFilterer, error) {
-	contract, err := bindLibAddressManager(address, nil, nil, filterer)
+// NewAddressManagerFilterer creates a new log filterer instance of AddressManager, bound to a specific deployed contract.
+func NewAddressManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressManagerFilterer, error) {
+	contract, err := bindAddressManager(address, nil, nil, filterer)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManagerFilterer{contract: contract}, nil
+	return &AddressManagerFilterer{contract: contract}, nil
 }
 
-// bindLibAddressManager binds a generic wrapper to an already deployed contract.
-func bindLibAddressManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(LibAddressManagerABI))
+// bindAddressManager binds a generic wrapper to an already deployed contract.
+func bindAddressManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(AddressManagerABI))
 	if err != nil {
 		return nil, err
 	}
@@ -167,46 +167,46 @@ func bindLibAddressManager(address common.Address, caller bind.ContractCaller, t
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named
 // returns.
-func (_LibAddressManager *LibAddressManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
-	return _LibAddressManager.Contract.LibAddressManagerCaller.contract.Call(opts, result, method, params...)
+func (_AddressManager *AddressManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _AddressManager.Contract.AddressManagerCaller.contract.Call(opts, result, method, params...)
 }
 
 // Transfer initiates a plain transaction to move funds to the contract, calling
 // its default method if one is available.
-func (_LibAddressManager *LibAddressManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.LibAddressManagerTransactor.contract.Transfer(opts)
+func (_AddressManager *AddressManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _AddressManager.Contract.AddressManagerTransactor.contract.Transfer(opts)
 }
 
 // Transact invokes the (paid) contract method with params as input values.
-func (_LibAddressManager *LibAddressManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.LibAddressManagerTransactor.contract.Transact(opts, method, params...)
+func (_AddressManager *AddressManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _AddressManager.Contract.AddressManagerTransactor.contract.Transact(opts, method, params...)
 }
 
 // Call invokes the (constant) contract method with params as input values and
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named
 // returns.
-func (_LibAddressManager *LibAddressManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
-	return _LibAddressManager.Contract.contract.Call(opts, result, method, params...)
+func (_AddressManager *AddressManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _AddressManager.Contract.contract.Call(opts, result, method, params...)
 }
 
 // Transfer initiates a plain transaction to move funds to the contract, calling
 // its default method if one is available.
-func (_LibAddressManager *LibAddressManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.contract.Transfer(opts)
+func (_AddressManager *AddressManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _AddressManager.Contract.contract.Transfer(opts)
 }
 
 // Transact invokes the (paid) contract method with params as input values.
-func (_LibAddressManager *LibAddressManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.contract.Transact(opts, method, params...)
+func (_AddressManager *AddressManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _AddressManager.Contract.contract.Transact(opts, method, params...)
 }
 
 // GetAddress is a free data retrieval call binding the contract method 0xbf40fac1.
 //
 // Solidity: function getAddress(string _name) view returns(address)
-func (_LibAddressManager *LibAddressManagerCaller) GetAddress(opts *bind.CallOpts, _name string) (common.Address, error) {
+func (_AddressManager *AddressManagerCaller) GetAddress(opts *bind.CallOpts, _name string) (common.Address, error) {
 	var out []interface{}
-	err := _LibAddressManager.contract.Call(opts, &out, "getAddress", _name)
+	err := _AddressManager.contract.Call(opts, &out, "getAddress", _name)
 
 	if err != nil {
 		return *new(common.Address), err
@@ -221,23 +221,23 @@ func (_LibAddressManager *LibAddressManagerCaller) GetAddress(opts *bind.CallOpt
 // GetAddress is a free data retrieval call binding the contract method 0xbf40fac1.
 //
 // Solidity: function getAddress(string _name) view returns(address)
-func (_LibAddressManager *LibAddressManagerSession) GetAddress(_name string) (common.Address, error) {
-	return _LibAddressManager.Contract.GetAddress(&_LibAddressManager.CallOpts, _name)
+func (_AddressManager *AddressManagerSession) GetAddress(_name string) (common.Address, error) {
+	return _AddressManager.Contract.GetAddress(&_AddressManager.CallOpts, _name)
 }
 
 // GetAddress is a free data retrieval call binding the contract method 0xbf40fac1.
 //
 // Solidity: function getAddress(string _name) view returns(address)
-func (_LibAddressManager *LibAddressManagerCallerSession) GetAddress(_name string) (common.Address, error) {
-	return _LibAddressManager.Contract.GetAddress(&_LibAddressManager.CallOpts, _name)
+func (_AddressManager *AddressManagerCallerSession) GetAddress(_name string) (common.Address, error) {
+	return _AddressManager.Contract.GetAddress(&_AddressManager.CallOpts, _name)
 }
 
 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 //
 // Solidity: function owner() view returns(address)
-func (_LibAddressManager *LibAddressManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+func (_AddressManager *AddressManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
 	var out []interface{}
-	err := _LibAddressManager.contract.Call(opts, &out, "owner")
+	err := _AddressManager.contract.Call(opts, &out, "owner")
 
 	if err != nil {
 		return *new(common.Address), err
@@ -252,83 +252,83 @@ func (_LibAddressManager *LibAddressManagerCaller) Owner(opts *bind.CallOpts) (c
 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 //
 // Solidity: function owner() view returns(address)
-func (_LibAddressManager *LibAddressManagerSession) Owner() (common.Address, error) {
-	return _LibAddressManager.Contract.Owner(&_LibAddressManager.CallOpts)
+func (_AddressManager *AddressManagerSession) Owner() (common.Address, error) {
+	return _AddressManager.Contract.Owner(&_AddressManager.CallOpts)
 }
 
 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 //
 // Solidity: function owner() view returns(address)
-func (_LibAddressManager *LibAddressManagerCallerSession) Owner() (common.Address, error) {
-	return _LibAddressManager.Contract.Owner(&_LibAddressManager.CallOpts)
+func (_AddressManager *AddressManagerCallerSession) Owner() (common.Address, error) {
+	return _AddressManager.Contract.Owner(&_AddressManager.CallOpts)
 }
 
 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
 //
 // Solidity: function renounceOwnership() returns()
-func (_LibAddressManager *LibAddressManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _LibAddressManager.contract.Transact(opts, "renounceOwnership")
+func (_AddressManager *AddressManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _AddressManager.contract.Transact(opts, "renounceOwnership")
 }
 
 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
 //
 // Solidity: function renounceOwnership() returns()
-func (_LibAddressManager *LibAddressManagerSession) RenounceOwnership() (*types.Transaction, error) {
-	return _LibAddressManager.Contract.RenounceOwnership(&_LibAddressManager.TransactOpts)
+func (_AddressManager *AddressManagerSession) RenounceOwnership() (*types.Transaction, error) {
+	return _AddressManager.Contract.RenounceOwnership(&_AddressManager.TransactOpts)
 }
 
 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
 //
 // Solidity: function renounceOwnership() returns()
-func (_LibAddressManager *LibAddressManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) {
-	return _LibAddressManager.Contract.RenounceOwnership(&_LibAddressManager.TransactOpts)
+func (_AddressManager *AddressManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _AddressManager.Contract.RenounceOwnership(&_AddressManager.TransactOpts)
 }
 
 // SetAddress is a paid mutator transaction binding the contract method 0x9b2ea4bd.
 //
 // Solidity: function setAddress(string _name, address _address) returns()
-func (_LibAddressManager *LibAddressManagerTransactor) SetAddress(opts *bind.TransactOpts, _name string, _address common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.contract.Transact(opts, "setAddress", _name, _address)
+func (_AddressManager *AddressManagerTransactor) SetAddress(opts *bind.TransactOpts, _name string, _address common.Address) (*types.Transaction, error) {
+	return _AddressManager.contract.Transact(opts, "setAddress", _name, _address)
 }
 
 // SetAddress is a paid mutator transaction binding the contract method 0x9b2ea4bd.
 //
 // Solidity: function setAddress(string _name, address _address) returns()
-func (_LibAddressManager *LibAddressManagerSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.SetAddress(&_LibAddressManager.TransactOpts, _name, _address)
+func (_AddressManager *AddressManagerSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error) {
+	return _AddressManager.Contract.SetAddress(&_AddressManager.TransactOpts, _name, _address)
 }
 
 // SetAddress is a paid mutator transaction binding the contract method 0x9b2ea4bd.
 //
 // Solidity: function setAddress(string _name, address _address) returns()
-func (_LibAddressManager *LibAddressManagerTransactorSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.SetAddress(&_LibAddressManager.TransactOpts, _name, _address)
+func (_AddressManager *AddressManagerTransactorSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error) {
+	return _AddressManager.Contract.SetAddress(&_AddressManager.TransactOpts, _name, _address)
 }
 
 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
 //
 // Solidity: function transferOwnership(address newOwner) returns()
-func (_LibAddressManager *LibAddressManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.contract.Transact(opts, "transferOwnership", newOwner)
+func (_AddressManager *AddressManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _AddressManager.contract.Transact(opts, "transferOwnership", newOwner)
 }
 
 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
 //
 // Solidity: function transferOwnership(address newOwner) returns()
-func (_LibAddressManager *LibAddressManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.TransferOwnership(&_LibAddressManager.TransactOpts, newOwner)
+func (_AddressManager *AddressManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _AddressManager.Contract.TransferOwnership(&_AddressManager.TransactOpts, newOwner)
 }
 
 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
 //
 // Solidity: function transferOwnership(address newOwner) returns()
-func (_LibAddressManager *LibAddressManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
-	return _LibAddressManager.Contract.TransferOwnership(&_LibAddressManager.TransactOpts, newOwner)
+func (_AddressManager *AddressManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _AddressManager.Contract.TransferOwnership(&_AddressManager.TransactOpts, newOwner)
 }
 
-// LibAddressManagerAddressSetIterator is returned from FilterAddressSet and is used to iterate over the raw logs and unpacked data for AddressSet events raised by the LibAddressManager contract.
-type LibAddressManagerAddressSetIterator struct {
-	Event *LibAddressManagerAddressSet // Event containing the contract specifics and raw log
+// AddressManagerAddressSetIterator is returned from FilterAddressSet and is used to iterate over the raw logs and unpacked data for AddressSet events raised by the AddressManager contract.
+type AddressManagerAddressSetIterator struct {
+	Event *AddressManagerAddressSet // Event containing the contract specifics and raw log
 
 	contract *bind.BoundContract // Generic contract to use for unpacking event data
 	event    string              // Event name to use for unpacking event data
@@ -342,7 +342,7 @@ type LibAddressManagerAddressSetIterator struct {
 // Next advances the iterator to the subsequent event, returning whether there
 // are any more events found. In case of a retrieval or parsing error, false is
 // returned and Error() can be queried for the exact failure.
-func (it *LibAddressManagerAddressSetIterator) Next() bool {
+func (it *AddressManagerAddressSetIterator) Next() bool {
 	// If the iterator failed, stop iterating
 	if it.fail != nil {
 		return false
@@ -351,7 +351,7 @@ func (it *LibAddressManagerAddressSetIterator) Next() bool {
 	if it.done {
 		select {
 		case log := <-it.logs:
-			it.Event = new(LibAddressManagerAddressSet)
+			it.Event = new(AddressManagerAddressSet)
 			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 				it.fail = err
 				return false
@@ -366,7 +366,7 @@ func (it *LibAddressManagerAddressSetIterator) Next() bool {
 	// Iterator still in progress, wait for either a data or an error event
 	select {
 	case log := <-it.logs:
-		it.Event = new(LibAddressManagerAddressSet)
+		it.Event = new(AddressManagerAddressSet)
 		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 			it.fail = err
 			return false
@@ -382,19 +382,19 @@ func (it *LibAddressManagerAddressSetIterator) Next() bool {
 }
 
 // Error returns any retrieval or parsing error occurred during filtering.
-func (it *LibAddressManagerAddressSetIterator) Error() error {
+func (it *AddressManagerAddressSetIterator) Error() error {
 	return it.fail
 }
 
 // Close terminates the iteration process, releasing any pending underlying
 // resources.
-func (it *LibAddressManagerAddressSetIterator) Close() error {
+func (it *AddressManagerAddressSetIterator) Close() error {
 	it.sub.Unsubscribe()
 	return nil
 }
 
-// LibAddressManagerAddressSet represents a AddressSet event raised by the LibAddressManager contract.
-type LibAddressManagerAddressSet struct {
+// AddressManagerAddressSet represents a AddressSet event raised by the AddressManager contract.
+type AddressManagerAddressSet struct {
 	Name       common.Hash
 	NewAddress common.Address
 	OldAddress common.Address
@@ -404,31 +404,31 @@ type LibAddressManagerAddressSet struct {
 // FilterAddressSet is a free log retrieval operation binding the contract event 0x9416a153a346f93d95f94b064ae3f148b6460473c6e82b3f9fc2521b873fcd6c.
 //
 // Solidity: event AddressSet(string indexed _name, address _newAddress, address _oldAddress)
-func (_LibAddressManager *LibAddressManagerFilterer) FilterAddressSet(opts *bind.FilterOpts, _name []string) (*LibAddressManagerAddressSetIterator, error) {
+func (_AddressManager *AddressManagerFilterer) FilterAddressSet(opts *bind.FilterOpts, _name []string) (*AddressManagerAddressSetIterator, error) {
 
 	var _nameRule []interface{}
 	for _, _nameItem := range _name {
 		_nameRule = append(_nameRule, _nameItem)
 	}
 
-	logs, sub, err := _LibAddressManager.contract.FilterLogs(opts, "AddressSet", _nameRule)
+	logs, sub, err := _AddressManager.contract.FilterLogs(opts, "AddressSet", _nameRule)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManagerAddressSetIterator{contract: _LibAddressManager.contract, event: "AddressSet", logs: logs, sub: sub}, nil
+	return &AddressManagerAddressSetIterator{contract: _AddressManager.contract, event: "AddressSet", logs: logs, sub: sub}, nil
 }
 
 // WatchAddressSet is a free log subscription operation binding the contract event 0x9416a153a346f93d95f94b064ae3f148b6460473c6e82b3f9fc2521b873fcd6c.
 //
 // Solidity: event AddressSet(string indexed _name, address _newAddress, address _oldAddress)
-func (_LibAddressManager *LibAddressManagerFilterer) WatchAddressSet(opts *bind.WatchOpts, sink chan<- *LibAddressManagerAddressSet, _name []string) (event.Subscription, error) {
+func (_AddressManager *AddressManagerFilterer) WatchAddressSet(opts *bind.WatchOpts, sink chan<- *AddressManagerAddressSet, _name []string) (event.Subscription, error) {
 
 	var _nameRule []interface{}
 	for _, _nameItem := range _name {
 		_nameRule = append(_nameRule, _nameItem)
 	}
 
-	logs, sub, err := _LibAddressManager.contract.WatchLogs(opts, "AddressSet", _nameRule)
+	logs, sub, err := _AddressManager.contract.WatchLogs(opts, "AddressSet", _nameRule)
 	if err != nil {
 		return nil, err
 	}
@@ -438,8 +438,8 @@ func (_LibAddressManager *LibAddressManagerFilterer) WatchAddressSet(opts *bind.
 			select {
 			case log := <-logs:
 				// New log arrived, parse the event and forward to the user
-				event := new(LibAddressManagerAddressSet)
-				if err := _LibAddressManager.contract.UnpackLog(event, "AddressSet", log); err != nil {
+				event := new(AddressManagerAddressSet)
+				if err := _AddressManager.contract.UnpackLog(event, "AddressSet", log); err != nil {
 					return err
 				}
 				event.Raw = log
@@ -463,18 +463,18 @@ func (_LibAddressManager *LibAddressManagerFilterer) WatchAddressSet(opts *bind.
 // ParseAddressSet is a log parse operation binding the contract event 0x9416a153a346f93d95f94b064ae3f148b6460473c6e82b3f9fc2521b873fcd6c.
 //
 // Solidity: event AddressSet(string indexed _name, address _newAddress, address _oldAddress)
-func (_LibAddressManager *LibAddressManagerFilterer) ParseAddressSet(log types.Log) (*LibAddressManagerAddressSet, error) {
-	event := new(LibAddressManagerAddressSet)
-	if err := _LibAddressManager.contract.UnpackLog(event, "AddressSet", log); err != nil {
+func (_AddressManager *AddressManagerFilterer) ParseAddressSet(log types.Log) (*AddressManagerAddressSet, error) {
+	event := new(AddressManagerAddressSet)
+	if err := _AddressManager.contract.UnpackLog(event, "AddressSet", log); err != nil {
 		return nil, err
 	}
 	event.Raw = log
 	return event, nil
 }
 
-// LibAddressManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the LibAddressManager contract.
-type LibAddressManagerOwnershipTransferredIterator struct {
-	Event *LibAddressManagerOwnershipTransferred // Event containing the contract specifics and raw log
+// AddressManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AddressManager contract.
+type AddressManagerOwnershipTransferredIterator struct {
+	Event *AddressManagerOwnershipTransferred // Event containing the contract specifics and raw log
 
 	contract *bind.BoundContract // Generic contract to use for unpacking event data
 	event    string              // Event name to use for unpacking event data
@@ -488,7 +488,7 @@ type LibAddressManagerOwnershipTransferredIterator struct {
 // Next advances the iterator to the subsequent event, returning whether there
 // are any more events found. In case of a retrieval or parsing error, false is
 // returned and Error() can be queried for the exact failure.
-func (it *LibAddressManagerOwnershipTransferredIterator) Next() bool {
+func (it *AddressManagerOwnershipTransferredIterator) Next() bool {
 	// If the iterator failed, stop iterating
 	if it.fail != nil {
 		return false
@@ -497,7 +497,7 @@ func (it *LibAddressManagerOwnershipTransferredIterator) Next() bool {
 	if it.done {
 		select {
 		case log := <-it.logs:
-			it.Event = new(LibAddressManagerOwnershipTransferred)
+			it.Event = new(AddressManagerOwnershipTransferred)
 			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 				it.fail = err
 				return false
@@ -512,7 +512,7 @@ func (it *LibAddressManagerOwnershipTransferredIterator) Next() bool {
 	// Iterator still in progress, wait for either a data or an error event
 	select {
 	case log := <-it.logs:
-		it.Event = new(LibAddressManagerOwnershipTransferred)
+		it.Event = new(AddressManagerOwnershipTransferred)
 		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 			it.fail = err
 			return false
@@ -528,19 +528,19 @@ func (it *LibAddressManagerOwnershipTransferredIterator) Next() bool {
 }
 
 // Error returns any retrieval or parsing error occurred during filtering.
-func (it *LibAddressManagerOwnershipTransferredIterator) Error() error {
+func (it *AddressManagerOwnershipTransferredIterator) Error() error {
 	return it.fail
 }
 
 // Close terminates the iteration process, releasing any pending underlying
 // resources.
-func (it *LibAddressManagerOwnershipTransferredIterator) Close() error {
+func (it *AddressManagerOwnershipTransferredIterator) Close() error {
 	it.sub.Unsubscribe()
 	return nil
 }
 
-// LibAddressManagerOwnershipTransferred represents a OwnershipTransferred event raised by the LibAddressManager contract.
-type LibAddressManagerOwnershipTransferred struct {
+// AddressManagerOwnershipTransferred represents a OwnershipTransferred event raised by the AddressManager contract.
+type AddressManagerOwnershipTransferred struct {
 	PreviousOwner common.Address
 	NewOwner      common.Address
 	Raw           types.Log // Blockchain specific contextual infos
@@ -549,7 +549,7 @@ type LibAddressManagerOwnershipTransferred struct {
 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 //
 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
-func (_LibAddressManager *LibAddressManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*LibAddressManagerOwnershipTransferredIterator, error) {
+func (_AddressManager *AddressManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AddressManagerOwnershipTransferredIterator, error) {
 
 	var previousOwnerRule []interface{}
 	for _, previousOwnerItem := range previousOwner {
@@ -560,17 +560,17 @@ func (_LibAddressManager *LibAddressManagerFilterer) FilterOwnershipTransferred(
 		newOwnerRule = append(newOwnerRule, newOwnerItem)
 	}
 
-	logs, sub, err := _LibAddressManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	logs, sub, err := _AddressManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 	if err != nil {
 		return nil, err
 	}
-	return &LibAddressManagerOwnershipTransferredIterator{contract: _LibAddressManager.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
+	return &AddressManagerOwnershipTransferredIterator{contract: _AddressManager.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
 }
 
 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 //
 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
-func (_LibAddressManager *LibAddressManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LibAddressManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
+func (_AddressManager *AddressManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AddressManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
 
 	var previousOwnerRule []interface{}
 	for _, previousOwnerItem := range previousOwner {
@@ -581,7 +581,7 @@ func (_LibAddressManager *LibAddressManagerFilterer) WatchOwnershipTransferred(o
 		newOwnerRule = append(newOwnerRule, newOwnerItem)
 	}
 
-	logs, sub, err := _LibAddressManager.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	logs, sub, err := _AddressManager.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 	if err != nil {
 		return nil, err
 	}
@@ -591,8 +591,8 @@ func (_LibAddressManager *LibAddressManagerFilterer) WatchOwnershipTransferred(o
 			select {
 			case log := <-logs:
 				// New log arrived, parse the event and forward to the user
-				event := new(LibAddressManagerOwnershipTransferred)
-				if err := _LibAddressManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+				event := new(AddressManagerOwnershipTransferred)
+				if err := _AddressManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 					return err
 				}
 				event.Raw = log
@@ -616,9 +616,9 @@ func (_LibAddressManager *LibAddressManagerFilterer) WatchOwnershipTransferred(o
 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 //
 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
-func (_LibAddressManager *LibAddressManagerFilterer) ParseOwnershipTransferred(log types.Log) (*LibAddressManagerOwnershipTransferred, error) {
-	event := new(LibAddressManagerOwnershipTransferred)
-	if err := _LibAddressManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+func (_AddressManager *AddressManagerFilterer) ParseOwnershipTransferred(log types.Log) (*AddressManagerOwnershipTransferred, error) {
+	event := new(AddressManagerOwnershipTransferred)
+	if err := _AddressManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 		return nil, err
 	}
 	event.Raw = log

packages/contracts-bedrock/.gas-snapshot

@@ -102,64 +102,15 @@ L2StandardBridge_Test:test_withdraw_onlyEOA() (gas: 251952)
 L2ToL1MessagePasserTest:test_burn() (gas: 112024)
 L2ToL1MessagePasserTest:test_initiateWithdrawal_fromContract() (gas: 67935)
 L2ToL1MessagePasserTest:test_initiateWithdrawal_fromEOA() (gas: 74851)
-Lib_RLPReader_Test:testReadBool() (gas: 1109)
-Lib_RLPReader_Test:test_readAddress() (gas: 1347)
-Lib_RLPReader_Test:test_readAddressSmall() (gas: 614)
-Lib_RLPReader_Test:test_readAddressTooLarge() (gas: 3646)
-Lib_RLPReader_Test:test_readAddressTooShort() (gas: 3603)
-Lib_RLPReader_Test:test_readBoolInvalidValue() (gas: 3677)
-Lib_RLPReader_Test:test_readBoolLargeInput() (gas: 3550)
-Lib_RLPReader_Test:test_readBytes32_revertOnList() (gas: 3998)
-Lib_RLPReader_Test:test_readBytes32_revertOnTooLong() (gas: 3588)
-Lib_RLPReader_Test:test_readBytes_bytestring00() (gas: 1823)
-Lib_RLPReader_Test:test_readBytes_bytestring01() (gas: 1846)
-Lib_RLPReader_Test:test_readBytes_bytestring7f() (gas: 1844)
-Lib_RLPReader_Test:test_readBytes_invalidListLength() (gas: 3812)
-Lib_RLPReader_Test:test_readBytes_invalidStringLength() (gas: 3768)
-Lib_RLPReader_Test:test_readBytes_revertListItem() (gas: 3922)
-Lib_RLPReader_Test:test_readList_dictTest1() (gas: 23791)
-Lib_RLPReader_Test:test_readList_empty() (gas: 4472)
-Lib_RLPReader_Test:test_readList_incorrectLengthInArray() (gas: 4213)
-Lib_RLPReader_Test:test_readList_int32Overflow() (gas: 3958)
-Lib_RLPReader_Test:test_readList_int32Overflow2() (gas: 4024)
-Lib_RLPReader_Test:test_readList_invalidShortList() (gas: 3858)
-Lib_RLPReader_Test:test_readList_invalidValue() (gas: 3790)
-Lib_RLPReader_Test:test_readList_leadingZerosInLongLengthArray1() (gas: 4196)
-Lib_RLPReader_Test:test_readList_leadingZerosInLongLengthArray2() (gas: 4180)
-Lib_RLPReader_Test:test_readList_leadingZerosInLongLengthList1() (gas: 38563)
-Lib_RLPReader_Test:test_readList_listOfLists() (gas: 9619)
-Lib_RLPReader_Test:test_readList_listOfLists2() (gas: 12479)
-Lib_RLPReader_Test:test_readList_longList1() (gas: 29013)
-Lib_RLPReader_Test:test_readList_longList2() (gas: 202895)
-Lib_RLPReader_Test:test_readList_longStringLength() (gas: 3856)
-Lib_RLPReader_Test:test_readList_multiList() (gas: 12025)
-Lib_RLPReader_Test:test_readList_nonOptimalLongLengthArray1() (gas: 4203)
-Lib_RLPReader_Test:test_readList_nonOptimalLongLengthArray2() (gas: 4226)
-Lib_RLPReader_Test:test_readList_notLongEnough() (gas: 3844)
-Lib_RLPReader_Test:test_readList_shortListMax1() (gas: 40662)
-Lib_RLPReader_Test:test_readList_stringList() (gas: 16796)
-Lib_RLPReader_Test:test_readString_emptyString() (gas: 1719)
-Lib_RLPReader_Test:test_readString_longString() (gas: 3076)
-Lib_RLPReader_Test:test_readString_longString2() (gas: 18524)
-Lib_RLPReader_Test:test_readString_shortString() (gas: 2280)
-Lib_RLPReader_Test:test_readString_shortString2() (gas: 2775)
-Lib_RLPReader_Test:test_readUint256_mediumInt1() (gas: 1235)
-Lib_RLPReader_Test:test_readUint256_mediumInt2() (gas: 1237)
-Lib_RLPReader_Test:test_readUint256_mediumInt3() (gas: 1238)
-Lib_RLPReader_Test:test_readUint256_smallInt() (gas: 1084)
-Lib_RLPReader_Test:test_readUint256_smallInt2() (gas: 1151)
-Lib_RLPReader_Test:test_readUint256_smallInt3() (gas: 1127)
-Lib_RLPReader_Test:test_readUint256_smallInt4() (gas: 1128)
-Lib_RLPReader_Test:test_readUint256_zero() (gas: 1258)
-OVM_ETH_Test:test_approve() (gas: 10760)
-OVM_ETH_Test:test_burn() (gas: 10675)
-OVM_ETH_Test:test_crossDomain() (gas: 10577)
-OVM_ETH_Test:test_decreaseAllowance() (gas: 10731)
-OVM_ETH_Test:test_increaseAllowance() (gas: 10741)
-OVM_ETH_Test:test_metadata() (gas: 15586)
-OVM_ETH_Test:test_mint() (gas: 10621)
-OVM_ETH_Test:test_transfer() (gas: 10793)
-OVM_ETH_Test:test_transferFrom() (gas: 13008)
+LegacyERC20ETH_Test:test_approve() (gas: 10796)
+LegacyERC20ETH_Test:test_burn() (gas: 10681)
+LegacyERC20ETH_Test:test_crossDomain() (gas: 10577)
+LegacyERC20ETH_Test:test_decreaseAllowance() (gas: 10731)
+LegacyERC20ETH_Test:test_increaseAllowance() (gas: 10741)
+LegacyERC20ETH_Test:test_metadata() (gas: 15586)
+LegacyERC20ETH_Test:test_mint() (gas: 10627)
+LegacyERC20ETH_Test:test_transfer() (gas: 10829)
+LegacyERC20ETH_Test:test_transferFrom() (gas: 13008)
 OptimismMintableERC20_Test:test_bridge() (gas: 9828)
 OptimismMintableERC20_Test:test_burn() (gas: 52826)
 OptimismMintableERC20_Test:test_burnRevertsFromNotBridge() (gas: 13219)
@@ -227,6 +178,55 @@ ProxyAdmin_Test:test_onlyOwnerSetProxyType() (gas: 10751)
 ProxyAdmin_Test:test_owner() (gas: 9818)
 ProxyAdmin_Test:test_proxyType() (gas: 20622)
 ProxyAdmin_Test:test_setImplementationName() (gas: 39002)
+RLPReader_Test:testReadBool() (gas: 1109)
+RLPReader_Test:test_readAddress() (gas: 1347)
+RLPReader_Test:test_readAddressSmall() (gas: 614)
+RLPReader_Test:test_readAddressTooLarge() (gas: 3646)
+RLPReader_Test:test_readAddressTooShort() (gas: 3603)
+RLPReader_Test:test_readBoolInvalidValue() (gas: 3677)
+RLPReader_Test:test_readBoolLargeInput() (gas: 3550)
+RLPReader_Test:test_readBytes32_revertOnList() (gas: 3998)
+RLPReader_Test:test_readBytes32_revertOnTooLong() (gas: 3588)
+RLPReader_Test:test_readBytes_bytestring00() (gas: 1823)
+RLPReader_Test:test_readBytes_bytestring01() (gas: 1846)
+RLPReader_Test:test_readBytes_bytestring7f() (gas: 1844)
+RLPReader_Test:test_readBytes_invalidListLength() (gas: 3812)
+RLPReader_Test:test_readBytes_invalidStringLength() (gas: 3768)
+RLPReader_Test:test_readBytes_revertListItem() (gas: 3922)
+RLPReader_Test:test_readList_dictTest1() (gas: 23791)
+RLPReader_Test:test_readList_empty() (gas: 4472)
+RLPReader_Test:test_readList_incorrectLengthInArray() (gas: 4213)
+RLPReader_Test:test_readList_int32Overflow() (gas: 3958)
+RLPReader_Test:test_readList_int32Overflow2() (gas: 4024)
+RLPReader_Test:test_readList_invalidShortList() (gas: 3858)
+RLPReader_Test:test_readList_invalidValue() (gas: 3790)
+RLPReader_Test:test_readList_leadingZerosInLongLengthArray1() (gas: 4196)
+RLPReader_Test:test_readList_leadingZerosInLongLengthArray2() (gas: 4180)
+RLPReader_Test:test_readList_leadingZerosInLongLengthList1() (gas: 38563)
+RLPReader_Test:test_readList_listOfLists() (gas: 9619)
+RLPReader_Test:test_readList_listOfLists2() (gas: 12479)
+RLPReader_Test:test_readList_longList1() (gas: 29013)
+RLPReader_Test:test_readList_longList2() (gas: 202895)
+RLPReader_Test:test_readList_longStringLength() (gas: 3856)
+RLPReader_Test:test_readList_multiList() (gas: 12025)
+RLPReader_Test:test_readList_nonOptimalLongLengthArray1() (gas: 4203)
+RLPReader_Test:test_readList_nonOptimalLongLengthArray2() (gas: 4226)
+RLPReader_Test:test_readList_notLongEnough() (gas: 3844)
+RLPReader_Test:test_readList_shortListMax1() (gas: 40662)
+RLPReader_Test:test_readList_stringList() (gas: 16796)
+RLPReader_Test:test_readString_emptyString() (gas: 1719)
+RLPReader_Test:test_readString_longString() (gas: 3076)
+RLPReader_Test:test_readString_longString2() (gas: 18524)
+RLPReader_Test:test_readString_shortString() (gas: 2280)
+RLPReader_Test:test_readString_shortString2() (gas: 2775)
+RLPReader_Test:test_readUint256_mediumInt1() (gas: 1235)
+RLPReader_Test:test_readUint256_mediumInt2() (gas: 1237)
+RLPReader_Test:test_readUint256_mediumInt3() (gas: 1238)
+RLPReader_Test:test_readUint256_smallInt() (gas: 1084)
+RLPReader_Test:test_readUint256_smallInt2() (gas: 1151)
+RLPReader_Test:test_readUint256_smallInt3() (gas: 1127)
+RLPReader_Test:test_readUint256_smallInt4() (gas: 1128)
+RLPReader_Test:test_readUint256_zero() (gas: 1258)
 ResourceMetering_Test:test_initialResourceParams() (gas: 8964)
 ResourceMetering_Test:test_updateNoGasDelta() (gas: 2008269)
 ResourceMetering_Test:test_updateOneEmptyBlock() (gas: 18123)

packages/contracts-bedrock/.storage-layout

@@ -230,26 +230,26 @@
 +--------------+--------------------------+------+--------+-------+----------------------------------------------------------+
 
 =======================
-➡ OVM_ETH
+➡ LegacyERC20ETH
 =======================
 
-+--------------+-------------------------------------------------+------+--------+-------+----------------------------------+
++--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 | Name         | Type                                            | Slot | Offset | Bytes | Contract                                           |
-+===========================================================================================================================+
-| _balances    | mapping(address => uint256)                     | 0    | 0      | 32    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| _allowances  | mapping(address => mapping(address => uint256)) | 1    | 0      | 32    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| _totalSupply | uint256                                         | 2    | 0      | 32    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| _name        | string                                          | 3    | 0      | 32    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| _symbol      | string                                          | 4    | 0      | 32    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| remoteToken  | address                                         | 5    | 0      | 20    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------|
-| bridge       | address                                         | 6    | 0      | 20    | contracts/L2/OVM_ETH.sol:OVM_ETH |
-+--------------+-------------------------------------------------+------+--------+-------+----------------------------------+
++=============================================================================================================================================+
+| _balances    | mapping(address => uint256)                     | 0    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| _allowances  | mapping(address => mapping(address => uint256)) | 1    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| _totalSupply | uint256                                         | 2    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| _name        | string                                          | 3    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| _symbol      | string                                          | 4    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| remoteToken  | address                                         | 5    | 0      | 20    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
+|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
+| bridge       | address                                         | 6    | 0      | 20    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
++--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 
 =======================
 ➡ SequencerFeeVault
@@ -292,7 +292,7 @@
 |--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | implementationName | mapping(address => string)                    | 2    | 0      | 32    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
 |--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
-| addressManager     | contract Lib_AddressManager                   | 3    | 0      | 20    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
+| addressManager     | contract AddressManager                       | 3    | 0      | 20    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
 |--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | upgrading          | bool                                          | 3    | 20     | 1     | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
 +--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------+

packages/contracts-bedrock/contracts/L1/L1CrossDomainMessenger.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { OptimismPortal } from "./OptimismPortal.sol";
 import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
 
@@ -40,7 +40,7 @@ contract L1CrossDomainMessenger is CrossDomainMessenger {
         portal = _portal;
         address[] memory blockedSystemAddresses = new address[](1);
         blockedSystemAddresses[0] = address(this);
-        _initialize(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER, blockedSystemAddresses);
+        _initialize(PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER, blockedSystemAddresses);
     }
 
     /**

packages/contracts-bedrock/contracts/L1/L1StandardBridge.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.9;
 
 import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { StandardBridge } from "../universal/StandardBridge.sol";
 
 /**
@@ -104,7 +104,7 @@ contract L1StandardBridge is StandardBridge, Initializable {
      * @param _messenger Address of the L1CrossDomainMessenger.
      */
     function initialize(address payable _messenger) public reinitializer(VERSION) {
-        _initialize(_messenger, payable(Lib_PredeployAddresses.L2_STANDARD_BRIDGE));
+        _initialize(_messenger, payable(PredeployAddresses.L2_STANDARD_BRIDGE));
     }
 
     /**

packages/contracts-bedrock/contracts/L1/OptimismPortal.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.10;
 import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 import { ExcessivelySafeCall } from "excessively-safe-call/src/ExcessivelySafeCall.sol";
 import { L2OutputOracle } from "./L2OutputOracle.sol";
-import { WithdrawalVerifier } from "../libraries/Lib_WithdrawalVerifier.sol";
+import { WithdrawalVerifier } from "../libraries/WithdrawalVerifier.sol";
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
 import { ResourceMetering } from "./ResourceMetering.sol";
 

packages/contracts-bedrock/contracts/L2/GasPriceOracle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.10;
 
 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { L1Block } from "../L2/L1Block.sol";
 
 /**
@@ -89,7 +89,7 @@ contract GasPriceOracle is Ownable {
      * @return Latest known L1 base fee.
      */
     function l1BaseFee() public view returns (uint256) {
-        return L1Block(Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES).basefee();
+        return L1Block(PredeployAddresses.L1_BLOCK_ATTRIBUTES).basefee();
     }
 
     /**

packages/contracts-bedrock/contracts/L2/L1BlockNumber.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.10;
 
 import { L1Block } from "./L1Block.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 /**
  * @custom:legacy
@@ -43,6 +43,6 @@ contract L1BlockNumber {
      * @return Latest L1 block number.
      */
     function getL1BlockNumber() public view returns (uint256) {
-        return L1Block(Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES).number();
+        return L1Block(PredeployAddresses.L1_BLOCK_ATTRIBUTES).number();
     }
 }

packages/contracts-bedrock/contracts/L2/L2CrossDomainMessenger.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.9;
 
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
 import { L2ToL1MessagePasser } from "./L2ToL1MessagePasser.sol";
 
@@ -23,7 +23,7 @@ contract L2CrossDomainMessenger is CrossDomainMessenger {
     function initialize(address _l1CrossDomainMessenger) external initializer {
         address[] memory blockedSystemAddresses = new address[](2);
         blockedSystemAddresses[0] = address(this);
-        blockedSystemAddresses[1] = Lib_PredeployAddresses.L2_TO_L1_MESSAGE_PASSER;
+        blockedSystemAddresses[1] = PredeployAddresses.L2_TO_L1_MESSAGE_PASSER;
 
         _initialize(_l1CrossDomainMessenger, blockedSystemAddresses);
     }
@@ -61,7 +61,8 @@ contract L2CrossDomainMessenger is CrossDomainMessenger {
         uint256 _value,
         bytes memory _data
     ) internal override {
-        L2ToL1MessagePasser(payable(Lib_PredeployAddresses.L2_TO_L1_MESSAGE_PASSER))
-            .initiateWithdrawal{ value: _value }(_to, _gasLimit, _data);
+        L2ToL1MessagePasser(payable(PredeployAddresses.L2_TO_L1_MESSAGE_PASSER)).initiateWithdrawal{
+            value: _value
+        }(_to, _gasLimit, _data);
     }
 }

packages/contracts-bedrock/contracts/L2/L2StandardBridge.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { StandardBridge } from "../universal/StandardBridge.sol";
 import { OptimismMintableERC20 } from "../universal/OptimismMintableERC20.sol";
 
@@ -84,7 +84,7 @@ contract L2StandardBridge is StandardBridge {
      * @param _otherBridge Address of the L1StandardBridge.
      */
     function initialize(address payable _otherBridge) public {
-        _initialize(payable(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER), _otherBridge);
+        _initialize(payable(PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER), _otherBridge);
     }
 
     /**
@@ -148,7 +148,7 @@ contract L2StandardBridge is StandardBridge {
         uint256 _amount,
         bytes calldata _extraData
     ) external payable virtual {
-        if (_l1Token == address(0) && _l2Token == Lib_PredeployAddresses.OVM_ETH) {
+        if (_l1Token == address(0) && _l2Token == PredeployAddresses.LEGACY_ERC20_ETH) {
             finalizeBridgeETH(_from, _to, _amount, _extraData);
         } else {
             finalizeBridgeERC20(_l2Token, _l1Token, _from, _to, _amount, _extraData);
@@ -176,7 +176,7 @@ contract L2StandardBridge is StandardBridge {
         bytes calldata _extraData
     ) internal {
         address l1Token = OptimismMintableERC20(_l2Token).l1Token();
-        if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
+        if (_l2Token == PredeployAddresses.LEGACY_ERC20_ETH) {
             require(msg.value == _amount, "ETH withdrawals must include sufficient ETH value.");
             _initiateBridgeETH(_from, _to, _amount, _minGasLimit, _extraData);
         } else {

packages/contracts-bedrock/contracts/L2/L2ToL1MessagePasser.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 
-import { WithdrawalVerifier } from "../libraries/Lib_WithdrawalVerifier.sol";
+import { WithdrawalVerifier } from "../libraries/WithdrawalVerifier.sol";
 import { Burn } from "../libraries/Burn.sol";
 
 /**

packages/contracts-bedrock/contracts/L2/SequencerFeeVault.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.9;
 
 /* Library Imports */
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 /* Contract Imports */
 import { L2StandardBridge } from "./L2StandardBridge.sol";
@@ -42,8 +42,8 @@ contract SequencerFeeVault {
 
         uint256 balance = address(this).balance;
 
-        L2StandardBridge(payable(Lib_PredeployAddresses.L2_STANDARD_BRIDGE)).withdrawTo{
+        L2StandardBridge(payable(PredeployAddresses.L2_STANDARD_BRIDGE)).withdrawTo{
             value: balance
-        }(Lib_PredeployAddresses.OVM_ETH, l1FeeWallet, balance, 0, bytes(""));
+        }(PredeployAddresses.LEGACY_ERC20_ETH, l1FeeWallet, balance, 0, bytes(""));
     }
 }

packages/contracts-bedrock/contracts/legacy/Lib_AddressManager.sol → packages/contracts-bedrock/contracts/legacy/AddressManager.sol

@@ -5,9 +5,9 @@ pragma solidity ^0.8.9;
 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 
 /**
- * @title Lib_AddressManager
+ * @title AddressManager
  */
-contract Lib_AddressManager is Ownable {
+contract AddressManager is Ownable {
     /**********
      * Events *
      **********/

packages/contracts-bedrock/contracts/legacy/Lib_AddressResolver.sol → packages/contracts-bedrock/contracts/legacy/AddressResolver.sol

@@ -2,27 +2,27 @@
 pragma solidity ^0.8.9;
 
 /* Library Imports */
-import { Lib_AddressManager } from "./Lib_AddressManager.sol";
+import { AddressManager } from "./AddressManager.sol";
 
 /**
- * @title Lib_AddressResolver
+ * @title AddressResolver
  */
-abstract contract Lib_AddressResolver {
+abstract contract AddressResolver {
     /*************
      * Variables *
      *************/
 
-    Lib_AddressManager public libAddressManager;
+    AddressManager public libAddressManager;
 
     /***************
      * Constructor *
      ***************/
 
     /**
-     * @param _libAddressManager Address of the Lib_AddressManager.
+     * @param _libAddressManager Address of the AddressManager.
      */
     constructor(address _libAddressManager) {
-        libAddressManager = Lib_AddressManager(_libAddressManager);
+        libAddressManager = AddressManager(_libAddressManager);
     }
 
     /********************

packages/contracts-bedrock/contracts/L2/OVM_ETH.sol → packages/contracts-bedrock/contracts/legacy/LegacyERC20ETH.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.9;
 
 /* Library Imports */
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 /* Contract Imports */
 import { OptimismMintableERC20 } from "../universal/OptimismMintableERC20.sol";
@@ -11,18 +11,18 @@ import { OptimismMintableERC20 } from "../universal/OptimismMintableERC20.sol";
  * @custom:legacy
  * @custom:proxied
  * @custom:predeploy 0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000
- * @title OVM_ETH
- * @notice OVM_ETH is a legacy contract that held ETH balances before the Bedrock upgrade. All
- *         ETH balances held within this contract were migrated to the state trie as part of the
- *         Bedrock upgrade. Functions within this contract that mutate state were already disabled
- *         as part of the EVM equivalence upgrade.
+ * @title LegacyERC20ETH
+ * @notice LegacyERC20ETH is a legacy contract that held ETH balances before the Bedrock upgrade.
+ *         All ETH balances held within this contract were migrated to the state trie as part of
+ *         the Bedrock upgrade. Functions within this contract that mutate state were already
+ *         disabled as part of the EVM equivalence upgrade.
  */
-contract OVM_ETH is OptimismMintableERC20 {
+contract LegacyERC20ETH is OptimismMintableERC20 {
     /**
      * @notice Initializes the contract as an Optimism Mintable ERC20.
      */
     constructor()
-        OptimismMintableERC20(Lib_PredeployAddresses.L2_STANDARD_BRIDGE, address(0), "Ether", "ETH")
+        OptimismMintableERC20(PredeployAddresses.L2_STANDARD_BRIDGE, address(0), "Ether", "ETH")
     {}
 
     /**
@@ -32,7 +32,7 @@ contract OVM_ETH is OptimismMintableERC20 {
      * @param _amount Amount of ETH to mint.
      */
     function mint(address _to, uint256 _amount) public virtual override {
-        revert("OVM_ETH: mint is disabled");
+        revert("LegacyERC20ETH: mint is disabled");
     }
 
     /**
@@ -42,7 +42,7 @@ contract OVM_ETH is OptimismMintableERC20 {
      * @param _amount Amount of ETH to burn.
      */
     function burn(address _from, uint256 _amount) public virtual override {
-        revert("OVM_ETH: burn is disabled");
+        revert("LegacyERC20ETH: burn is disabled");
     }
 
     /**
@@ -52,7 +52,7 @@ contract OVM_ETH is OptimismMintableERC20 {
      * @param _amount    Amount of ETH to send.
      */
     function transfer(address _recipient, uint256 _amount) public virtual override returns (bool) {
-        revert("OVM_ETH: transfer is disabled");
+        revert("LegacyERC20ETH: transfer is disabled");
     }
 
     /**
@@ -62,7 +62,7 @@ contract OVM_ETH is OptimismMintableERC20 {
      * @param _amount  Amount of ETH to approve.
      */
     function approve(address _spender, uint256 _amount) public virtual override returns (bool) {
-        revert("OVM_ETH: approve is disabled");
+        revert("LegacyERC20ETH: approve is disabled");
     }
 
     /**
@@ -77,7 +77,7 @@ contract OVM_ETH is OptimismMintableERC20 {
         address _recipient,
         uint256 _amount
     ) public virtual override returns (bool) {
-        revert("OVM_ETH: transferFrom is disabled");
+        revert("LegacyERC20ETH: transferFrom is disabled");
     }
 
     /**
@@ -92,7 +92,7 @@ contract OVM_ETH is OptimismMintableERC20 {
         override
         returns (bool)
     {
-        revert("OVM_ETH: increaseAllowance is disabled");
+        revert("LegacyERC20ETH: increaseAllowance is disabled");
     }
 
     /**
@@ -107,6 +107,6 @@ contract OVM_ETH is OptimismMintableERC20 {
         override
         returns (bool)
     {
-        revert("OVM_ETH: decreaseAllowance is disabled");
+        revert("LegacyERC20ETH: decreaseAllowance is disabled");
     }
 }

packages/contracts-bedrock/contracts/legacy/Lib_ResolvedDelegateProxy.sol → packages/contracts-bedrock/contracts/legacy/ResolvedDelegateProxy.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.9;
 
-import { Lib_AddressManager } from "./Lib_AddressManager.sol";
+import { AddressManager } from "./AddressManager.sol";
 
 /**
- * @title Lib_ResolvedDelegateProxy
+ * @title ResolvedDelegateProxy
  */
-contract Lib_ResolvedDelegateProxy {
+contract ResolvedDelegateProxy {
     /*************
      * Variables *
      *************/
@@ -20,18 +20,18 @@ contract Lib_ResolvedDelegateProxy {
     //      in the near future. Due to the very limited way that we are using it, this flaw is
     //      not an issue in our system.
     mapping(address => string) private implementationName;
-    mapping(address => Lib_AddressManager) private addressManager;
+    mapping(address => AddressManager) private addressManager;
 
     /***************
      * Constructor *
      ***************/
 
     /**
-     * @param _libAddressManager Address of the Lib_AddressManager.
+     * @param _libAddressManager Address of the AddressManager.
      * @param _implementationName implementationName of the contract to proxy to.
      */
     constructor(address _libAddressManager, string memory _implementationName) {
-        addressManager[address(this)] = Lib_AddressManager(_libAddressManager);
+        addressManager[address(this)] = AddressManager(_libAddressManager);
         implementationName[address(this)] = _implementationName;
     }
 

packages/contracts-bedrock/contracts/libraries/Lib_BytesUtils.sol → packages/contracts-bedrock/contracts/libraries/BytesUtils.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_BytesUtils
+ * @title BytesUtils
  */
-library Lib_BytesUtils {
+library BytesUtils {
     /**********************
      * Internal Functions *
      **********************/

packages/contracts-bedrock/contracts/libraries/Lib_CrossDomainHashing.sol → packages/contracts-bedrock/contracts/libraries/CrossDomainHashing.sol

 //SPDX-License-Identifier: MIT
 pragma solidity 0.8.10;
 
-import { Lib_CrossDomainUtils } from "./Lib_CrossDomainUtils.sol";
-import { Lib_RLPWriter } from "./rlp/Lib_RLPWriter.sol";
+import { CrossDomainUtils } from "./CrossDomainUtils.sol";
+import { RLPWriter } from "./rlp/RLPWriter.sol";
 
 /**
  * @title CrossDomainHashing
  * This library is responsible for holding cross domain utility
  * functions.
- * TODO(tynes): merge with Lib_CrossDomainUtils
+ * TODO(tynes): merge with CrossDomainUtils
  * TODO(tynes): fill out more devdocs
  */
 library CrossDomainHashing {
@@ -89,22 +89,22 @@ library CrossDomainHashing {
 
         bytes[] memory raw = new bytes[](7);
 
-        raw[0] = Lib_RLPWriter.writeBytes(bytes32ToBytes(source));
-        raw[1] = Lib_RLPWriter.writeAddress(_from);
+        raw[0] = RLPWriter.writeBytes(bytes32ToBytes(source));
+        raw[1] = RLPWriter.writeAddress(_from);
 
         if (_isCreate == true) {
             require(_to == address(0));
-            raw[2] = Lib_RLPWriter.writeBytes("");
+            raw[2] = RLPWriter.writeBytes("");
         } else {
-            raw[2] = Lib_RLPWriter.writeAddress(_to);
+            raw[2] = RLPWriter.writeAddress(_to);
         }
 
-        raw[3] = Lib_RLPWriter.writeUint(_mint);
-        raw[4] = Lib_RLPWriter.writeUint(_value);
-        raw[5] = Lib_RLPWriter.writeUint(_gas);
-        raw[6] = Lib_RLPWriter.writeBytes(_data);
+        raw[3] = RLPWriter.writeUint(_mint);
+        raw[4] = RLPWriter.writeUint(_value);
+        raw[5] = RLPWriter.writeUint(_gas);
+        raw[6] = RLPWriter.writeBytes(_data);
 
-        bytes memory encoded = Lib_RLPWriter.writeList(raw);
+        bytes memory encoded = RLPWriter.writeList(raw);
         return abi.encodePacked(uint8(0x7e), uint8(0x0), encoded);
     }
 
@@ -193,7 +193,7 @@ library CrossDomainHashing {
         bytes memory _data,
         uint256 _nonce
     ) internal pure returns (bytes memory) {
-        return Lib_CrossDomainUtils.encodeXDomainCalldata(_target, _sender, _data, _nonce);
+        return CrossDomainUtils.encodeXDomainCalldata(_target, _sender, _data, _nonce);
     }
 
     /**

packages/contracts-bedrock/contracts/libraries/Lib_CrossDomainUtils.sol → packages/contracts-bedrock/contracts/libraries/CrossDomainUtils.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_CrossDomainUtils
+ * @title CrossDomainUtils
  */
-library Lib_CrossDomainUtils {
+library CrossDomainUtils {
     /**
      * Generates the correct cross domain calldata for a message.
      * @param _target Target contract address.

packages/contracts-bedrock/contracts/libraries/Lib_DefaultValues.sol → packages/contracts-bedrock/contracts/libraries/DefaultValues.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_DefaultValues
+ * @title DefaultValues
  */
-library Lib_DefaultValues {
+library DefaultValues {
     // The default x-domain message sender being set to a non-zero value makes
     // deployment a bit more expensive, but in exchange the refund on every call to
     // `relayMessage` by the L1 and L2 messengers will be higher.

packages/contracts-bedrock/contracts/libraries/Lib_PredeployAddresses.sol → packages/contracts-bedrock/contracts/libraries/PredeployAddresses.sol

@@ -2,16 +2,16 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_PredeployAddresses
+ * @title PredeployAddresses
  */
-library Lib_PredeployAddresses {
+library PredeployAddresses {
     address internal constant L2_TO_L1_MESSAGE_PASSER = 0x4200000000000000000000000000000000000000;
     address internal constant L1_MESSAGE_SENDER = 0x4200000000000000000000000000000000000001;
     address internal constant DEPLOYER_WHITELIST = 0x4200000000000000000000000000000000000002;
-    address payable internal constant OVM_ETH = payable(0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000);
+    address internal constant LEGACY_ERC20_ETH = 0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000;
     address internal constant L2_CROSS_DOMAIN_MESSENGER =
         0x4200000000000000000000000000000000000007;
-    address internal constant LIB_ADDRESS_MANAGER = 0x4200000000000000000000000000000000000008;
+    address internal constant ADDRESS_MANAGER = 0x4200000000000000000000000000000000000008;
     address internal constant PROXY_EOA = 0x4200000000000000000000000000000000000009;
     address internal constant L2_STANDARD_BRIDGE = 0x4200000000000000000000000000000000000010;
     address internal constant SEQUENCER_FEE_WALLET = 0x4200000000000000000000000000000000000011;

packages/contracts-bedrock/contracts/libraries/Lib_WithdrawalVerifier.sol → packages/contracts-bedrock/contracts/libraries/WithdrawalVerifier.sol

@@ -2,8 +2,8 @@
 pragma solidity 0.8.10;
 
 /* Library Imports */
-import { Lib_SecureMerkleTrie } from "./trie/Lib_SecureMerkleTrie.sol";
-import { Lib_CrossDomainUtils } from "./Lib_CrossDomainUtils.sol";
+import { SecureMerkleTrie } from "./trie/SecureMerkleTrie.sol";
+import { CrossDomainUtils } from "./CrossDomainUtils.sol";
 
 /**
  * @title WithdrawalVerifier
@@ -80,7 +80,7 @@ library WithdrawalVerifier {
         );
 
         return
-            Lib_SecureMerkleTrie.verifyInclusionProof(
+            SecureMerkleTrie.verifyInclusionProof(
                 abi.encode(storageKey),
                 hex"01",
                 _withdrawalProof,

packages/contracts-bedrock/contracts/libraries/rlp/Lib_RLPReader.sol → packages/contracts-bedrock/contracts/libraries/rlp/RLPReader.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_RLPReader
+ * @title RLPReader
  * @dev Adapted from "RLPReader" by Hamdi Allam (hamdi.allam97@gmail.com).
  */
-library Lib_RLPReader {
+library RLPReader {
     /*************
      * Constants *
      *************/
@@ -203,7 +203,7 @@ library Lib_RLPReader {
             out := byte(0, mload(ptr))
         }
 
-        require(out == 0 || out == 1, "Lib_RLPReader: Invalid RLP boolean value, must be 0 or 1");
+        require(out == 0 || out == 1, "RLPReader: Invalid RLP boolean value, must be 0 or 1");
 
         return out != 0;
     }

packages/contracts-bedrock/contracts/libraries/rlp/Lib_RLPWriter.sol → packages/contracts-bedrock/contracts/libraries/rlp/RLPWriter.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.9;
 
 /**
- * @title Lib_RLPWriter
+ * @title RLPWriter
  * @author Bakaoh (with modifications)
  */
-library Lib_RLPWriter {
+library RLPWriter {
     /**********************
      * Internal Functions *
      **********************/

packages/contracts-bedrock/contracts/libraries/trie/Lib_MerkleTrie.sol → packages/contracts-bedrock/contracts/libraries/trie/MerkleTrie.sol

@@ -2,14 +2,14 @@
 pragma solidity ^0.8.9;
 
 /* Library Imports */
-import { Lib_BytesUtils } from "../Lib_BytesUtils.sol";
-import { Lib_RLPReader } from "../rlp/Lib_RLPReader.sol";
-import { Lib_RLPWriter } from "../rlp/Lib_RLPWriter.sol";
+import { BytesUtils } from "../BytesUtils.sol";
+import { RLPReader } from "../rlp/RLPReader.sol";
+import { RLPWriter } from "../rlp/RLPWriter.sol";
 
 /**
- * @title Lib_MerkleTrie
+ * @title MerkleTrie
  */
-library Lib_MerkleTrie {
+library MerkleTrie {
     /*******************
      * Data Structures *
      *******************/
@@ -22,7 +22,7 @@ library Lib_MerkleTrie {
 
     struct TrieNode {
         bytes encoded;
-        Lib_RLPReader.RLPItem[] decoded;
+        RLPReader.RLPItem[] decoded;
     }
 
     /**********************
@@ -73,7 +73,7 @@ library Lib_MerkleTrie {
     ) internal pure returns (bool _verified) {
         (bool exists, bytes memory value) = get(_key, _proof, _root);
 
-        return (exists && Lib_BytesUtils.equal(_value, value));
+        return (exists && BytesUtils.equal(_value, value));
     }
 
     /**
@@ -132,7 +132,7 @@ library Lib_MerkleTrie {
         )
     {
         uint256 pathLength = 0;
-        bytes memory key = Lib_BytesUtils.toNibbles(_key);
+        bytes memory key = BytesUtils.toNibbles(_key);
 
         bytes32 currentNodeID = _root;
         uint256 currentKeyIndex = 0;
@@ -160,7 +160,7 @@ library Lib_MerkleTrie {
             } else {
                 // Nodes smaller than 31 bytes aren't hashed.
                 require(
-                    Lib_BytesUtils.toBytes32(currentNode.encoded) == currentNodeID,
+                    BytesUtils.toBytes32(currentNode.encoded) == currentNodeID,
                     "Invalid internal node hash"
                 );
             }
@@ -174,7 +174,7 @@ library Lib_MerkleTrie {
                     // We're not at the end of the key yet.
                     // Figure out what the next node ID should be and continue.
                     uint8 branchKey = uint8(key[currentKeyIndex]);
-                    Lib_RLPReader.RLPItem memory nextNode = currentNode.decoded[branchKey];
+                    RLPReader.RLPItem memory nextNode = currentNode.decoded[branchKey];
                     currentNodeID = _getNodeID(nextNode);
                     currentKeyIncrement = 1;
                     continue;
@@ -183,8 +183,8 @@ library Lib_MerkleTrie {
                 bytes memory path = _getNodePath(currentNode);
                 uint8 prefix = uint8(path[0]);
                 uint8 offset = 2 - (prefix % 2);
-                bytes memory pathRemainder = Lib_BytesUtils.slice(path, offset);
-                bytes memory keyRemainder = Lib_BytesUtils.slice(key, currentKeyIndex);
+                bytes memory pathRemainder = BytesUtils.slice(path, offset);
+                bytes memory keyRemainder = BytesUtils.slice(key, currentKeyIndex);
                 uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder);
 
                 if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
@@ -224,7 +224,7 @@ library Lib_MerkleTrie {
 
         // If our node ID is NULL, then we're at a dead end.
         bool isFinalNode = currentNodeID == bytes32(RLP_NULL);
-        return (pathLength, Lib_BytesUtils.slice(key, currentKeyIndex), isFinalNode);
+        return (pathLength, BytesUtils.slice(key, currentKeyIndex), isFinalNode);
     }
 
     /**
@@ -233,12 +233,12 @@ library Lib_MerkleTrie {
      * @return _parsed Proof parsed into easily accessible structs.
      */
     function _parseProof(bytes memory _proof) private pure returns (TrieNode[] memory _parsed) {
-        Lib_RLPReader.RLPItem[] memory nodes = Lib_RLPReader.readList(_proof);
+        RLPReader.RLPItem[] memory nodes = RLPReader.readList(_proof);
         TrieNode[] memory proof = new TrieNode[](nodes.length);
 
         for (uint256 i = 0; i < nodes.length; i++) {
-            bytes memory encoded = Lib_RLPReader.readBytes(nodes[i]);
-            proof[i] = TrieNode({ encoded: encoded, decoded: Lib_RLPReader.readList(encoded) });
+            bytes memory encoded = RLPReader.readBytes(nodes[i]);
+            proof[i] = TrieNode({ encoded: encoded, decoded: RLPReader.readList(encoded) });
         }
 
         return proof;
@@ -251,18 +251,18 @@ library Lib_MerkleTrie {
      * @param _node Node to pull an ID for.
      * @return _nodeID ID for the node, depending on the size of its contents.
      */
-    function _getNodeID(Lib_RLPReader.RLPItem memory _node) private pure returns (bytes32 _nodeID) {
+    function _getNodeID(RLPReader.RLPItem memory _node) private pure returns (bytes32 _nodeID) {
         bytes memory nodeID;
 
         if (_node.length < 32) {
             // Nodes smaller than 32 bytes are RLP encoded.
-            nodeID = Lib_RLPReader.readRawBytes(_node);
+            nodeID = RLPReader.readRawBytes(_node);
         } else {
             // Nodes 32 bytes or larger are hashed.
-            nodeID = Lib_RLPReader.readBytes(_node);
+            nodeID = RLPReader.readBytes(_node);
         }
 
-        return Lib_BytesUtils.toBytes32(nodeID);
+        return BytesUtils.toBytes32(nodeID);
     }
 
     /**
@@ -271,7 +271,7 @@ library Lib_MerkleTrie {
      * @return _path Node path, converted to an array of nibbles.
      */
     function _getNodePath(TrieNode memory _node) private pure returns (bytes memory _path) {
-        return Lib_BytesUtils.toNibbles(Lib_RLPReader.readBytes(_node.decoded[0]));
+        return BytesUtils.toNibbles(RLPReader.readBytes(_node.decoded[0]));
     }
 
     /**
@@ -280,7 +280,7 @@ library Lib_MerkleTrie {
      * @return _value Node value, as hex bytes.
      */
     function _getNodeValue(TrieNode memory _node) private pure returns (bytes memory _value) {
-        return Lib_RLPReader.readBytes(_node.decoded[_node.decoded.length - 1]);
+        return RLPReader.readBytes(_node.decoded[_node.decoded.length - 1]);
     }
 
     /**

packages/contracts-bedrock/contracts/libraries/trie/Lib_SecureMerkleTrie.sol → packages/contracts-bedrock/contracts/libraries/trie/SecureMerkleTrie.sol

@@ -2,12 +2,12 @@
 pragma solidity ^0.8.9;
 
 /* Library Imports */
-import { Lib_MerkleTrie } from "./Lib_MerkleTrie.sol";
+import { MerkleTrie } from "./MerkleTrie.sol";
 
 /**
- * @title Lib_SecureMerkleTrie
+ * @title SecureMerkleTrie
  */
-library Lib_SecureMerkleTrie {
+library SecureMerkleTrie {
     /**********************
      * Internal Functions *
      **********************/
@@ -31,7 +31,7 @@ library Lib_SecureMerkleTrie {
         bytes32 _root
     ) internal pure returns (bool _verified) {
         bytes memory key = _getSecureKey(_key);
-        return Lib_MerkleTrie.verifyInclusionProof(key, _value, _proof, _root);
+        return MerkleTrie.verifyInclusionProof(key, _value, _proof, _root);
     }
 
     /**
@@ -48,7 +48,7 @@ library Lib_SecureMerkleTrie {
         bytes32 _root
     ) internal pure returns (bool _exists, bytes memory _value) {
         bytes memory key = _getSecureKey(_key);
-        return Lib_MerkleTrie.get(key, _proof, _root);
+        return MerkleTrie.get(key, _proof, _root);
     }
 
     /*********************

packages/contracts-bedrock/contracts/test/CommonTest.t.sol

@@ -14,13 +14,13 @@ import { L2ToL1MessagePasser } from "../L2/L2ToL1MessagePasser.sol";
 import { L1CrossDomainMessenger } from "../L1/L1CrossDomainMessenger.sol";
 import { L2CrossDomainMessenger } from "../L2/L2CrossDomainMessenger.sol";
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
-import { OVM_ETH } from "../L2/OVM_ETH.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { LegacyERC20ETH } from "../legacy/LegacyERC20ETH.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { Proxy } from "../universal/Proxy.sol";
 import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
-import { Lib_ResolvedDelegateProxy } from "../legacy/Lib_ResolvedDelegateProxy.sol";
-import { Lib_AddressManager } from "../legacy/Lib_AddressManager.sol";
+import { ResolvedDelegateProxy } from "../legacy/ResolvedDelegateProxy.sol";
+import { AddressManager } from "../legacy/AddressManager.sol";
 import { L1ChugSplashProxy } from "../legacy/L1ChugSplashProxy.sol";
 import { iL1ChugSplashDeployer } from "../legacy/L1ChugSplashProxy.sol";
 
@@ -130,12 +130,12 @@ contract Portal_Initializer is L2OutputOracle_Initializer {
 
 contract Messenger_Initializer is L2OutputOracle_Initializer {
     OptimismPortal op;
-    Lib_AddressManager addressManager;
+    AddressManager addressManager;
     L1CrossDomainMessenger L1Messenger;
     L2CrossDomainMessenger L2Messenger =
-        L2CrossDomainMessenger(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER);
+        L2CrossDomainMessenger(PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER);
     L2ToL1MessagePasser messagePasser =
-        L2ToL1MessagePasser(payable(Lib_PredeployAddresses.L2_TO_L1_MESSAGE_PASSER));
+        L2ToL1MessagePasser(payable(PredeployAddresses.L2_TO_L1_MESSAGE_PASSER));
 
     event SentMessage(
         address indexed target,
@@ -177,7 +177,7 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
 
         // Deploy the address manager
         vm.prank(multisig);
-        addressManager = new Lib_AddressManager();
+        addressManager = new AddressManager();
 
         // Setup implementation
         L1CrossDomainMessenger L1MessengerImpl = new L1CrossDomainMessenger(op);
@@ -185,7 +185,7 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
         // Setup the address manager and proxy
         vm.prank(multisig);
         addressManager.setAddress("OVM_L1CrossDomainMessenger", address(L1MessengerImpl));
-        Lib_ResolvedDelegateProxy proxy = new Lib_ResolvedDelegateProxy(
+        ResolvedDelegateProxy proxy = new ResolvedDelegateProxy(
             address(addressManager),
             "OVM_L1CrossDomainMessenger"
         );
@@ -193,7 +193,7 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
         L1Messenger.initialize(op);
 
         vm.etch(
-            Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
+            PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
             address(new L2CrossDomainMessenger()).code
         );
 
@@ -201,16 +201,18 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
 
         // Set the L2ToL1MessagePasser at the correct address
         vm.etch(
-            Lib_PredeployAddresses.L2_TO_L1_MESSAGE_PASSER,
+            PredeployAddresses.L2_TO_L1_MESSAGE_PASSER,
             address(new L2ToL1MessagePasser()).code
         );
+
+        // Label addresses
         vm.label(address(addressManager), "AddressManager");
         vm.label(address(L1MessengerImpl), "L1CrossDomainMessenger_Impl");
         vm.label(address(L1Messenger), "L1CrossDomainMessenger_Proxy");
-        vm.label(Lib_PredeployAddresses.OVM_ETH, "OVM_ETH");
-        vm.label(Lib_PredeployAddresses.OVM_ETH, "OVM_ETH");
-        vm.label(Lib_PredeployAddresses.L2_TO_L1_MESSAGE_PASSER, "L2ToL1MessagePasser");
-        vm.label(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER, "L2CrossDomainMessenger");
+        vm.label(PredeployAddresses.LEGACY_ERC20_ETH, "LegacyERC20ETH");
+        vm.label(PredeployAddresses.L2_TO_L1_MESSAGE_PASSER, "L2ToL1MessagePasser");
+        vm.label(PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER, "L2CrossDomainMessenger");
+
         vm.label(
             AddressAliasHelper.applyL1ToL2Alias(address(L1Messenger)),
             "L1CrossDomainMessenger_aliased"
@@ -331,8 +333,8 @@ contract Bridge_Initializer is Messenger_Initializer {
     function setUp() public virtual override {
         super.setUp();
 
-        vm.label(Lib_PredeployAddresses.L2_STANDARD_BRIDGE, "L2StandardBridge");
-        vm.label(Lib_PredeployAddresses.L2_STANDARD_TOKEN_FACTORY, "L2StandardTokenFactory");
+        vm.label(PredeployAddresses.L2_STANDARD_BRIDGE, "L2StandardBridge");
+        vm.label(PredeployAddresses.L2_STANDARD_TOKEN_FACTORY, "L2StandardTokenFactory");
 
         // Deploy the L1 bridge and initialize it with the address of the
         // L1CrossDomainMessenger
@@ -357,19 +359,19 @@ contract Bridge_Initializer is Messenger_Initializer {
         // Deploy the L2StandardBridge, move it to the correct predeploy
         // address and then initialize it
         L2StandardBridge l2B = new L2StandardBridge();
-        vm.etch(Lib_PredeployAddresses.L2_STANDARD_BRIDGE, address(l2B).code);
-        L2Bridge = L2StandardBridge(payable(Lib_PredeployAddresses.L2_STANDARD_BRIDGE));
+        vm.etch(PredeployAddresses.L2_STANDARD_BRIDGE, address(l2B).code);
+        L2Bridge = L2StandardBridge(payable(PredeployAddresses.L2_STANDARD_BRIDGE));
         L2Bridge.initialize(payable(address(L1Bridge)));
 
         // Set up the L2 mintable token factory
         OptimismMintableTokenFactory factory = new OptimismMintableTokenFactory();
-        vm.etch(Lib_PredeployAddresses.L2_STANDARD_TOKEN_FACTORY, address(factory).code);
+        vm.etch(PredeployAddresses.L2_STANDARD_TOKEN_FACTORY, address(factory).code);
         L2TokenFactory = OptimismMintableTokenFactory(
-            Lib_PredeployAddresses.L2_STANDARD_TOKEN_FACTORY
+            PredeployAddresses.L2_STANDARD_TOKEN_FACTORY
         );
-        L2TokenFactory.initialize(Lib_PredeployAddresses.L2_STANDARD_BRIDGE);
+        L2TokenFactory.initialize(PredeployAddresses.L2_STANDARD_BRIDGE);
 
-        vm.etch(Lib_PredeployAddresses.OVM_ETH, address(new OVM_ETH()).code);
+        vm.etch(PredeployAddresses.LEGACY_ERC20_ETH, address(new LegacyERC20ETH()).code);
 
         L1Token = new ERC20("Native L1 Token", "L1T");
 

packages/contracts-bedrock/contracts/test/CrossDomainHashing.t.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.10;
 
 import { CommonTest } from "./CommonTest.t.sol";
-import { CrossDomainHashing } from "../libraries/Lib_CrossDomainHashing.sol";
+import { CrossDomainHashing } from "../libraries/CrossDomainHashing.sol";
 
 contract CrossDomainHashing_Test is CommonTest {
     function test_nonceVersioning(uint240 _nonce, uint16 _version) external {

packages/contracts-bedrock/contracts/test/GasPriceOracle.t.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.10;
 import { CommonTest } from "./CommonTest.t.sol";
 import { GasPriceOracle } from "../L2/GasPriceOracle.sol";
 import { L1Block } from "../L2/L1Block.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 contract GasPriceOracle_Test is CommonTest {
 
@@ -19,11 +19,11 @@ contract GasPriceOracle_Test is CommonTest {
     function setUp() external {
         // place the L1Block contract at the predeploy address
         vm.etch(
-            Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES,
+            PredeployAddresses.L1_BLOCK_ATTRIBUTES,
             address(new L1Block()).code
         );
 
-        l1Block = L1Block(Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES);
+        l1Block = L1Block(PredeployAddresses.L1_BLOCK_ATTRIBUTES);
         depositor = l1Block.DEPOSITOR_ACCOUNT();
 
         // We are not setting the gas oracle at its predeploy

packages/contracts-bedrock/contracts/test/L1BlockNumber.t.sol

@@ -4,15 +4,15 @@ pragma solidity 0.8.10;
 import { Test } from "forge-std/Test.sol";
 import { L1Block } from "../L2/L1Block.sol";
 import { L1BlockNumber } from "../L2/L1BlockNumber.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 contract L1BlockNumberTest is Test {
     L1Block lb;
     L1BlockNumber bn;
 
     function setUp() external {
-        vm.etch(Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES, address(new L1Block()).code);
-        lb = L1Block(Lib_PredeployAddresses.L1_BLOCK_ATTRIBUTES);
+        vm.etch(PredeployAddresses.L1_BLOCK_ATTRIBUTES, address(new L1Block()).code);
+        lb = L1Block(PredeployAddresses.L1_BLOCK_ATTRIBUTES);
         bn = new L1BlockNumber();
         vm.prank(lb.DEPOSITOR_ACCOUNT());
         lb.setL1BlockValues(uint64(999), uint64(2), 3, keccak256(abi.encode(1)), uint64(4));

packages/contracts-bedrock/contracts/test/L1CrossDomainMessenger.t.sol

@@ -7,16 +7,16 @@ import { L2OutputOracle_Initializer } from "./L2OutputOracle.t.sol";
 
 /* Libraries */
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
-import { Lib_DefaultValues } from "../libraries/Lib_DefaultValues.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
-import { Lib_CrossDomainUtils } from "../libraries/Lib_CrossDomainUtils.sol";
-import { WithdrawalVerifier } from "../libraries/Lib_WithdrawalVerifier.sol";
+import { DefaultValues } from "../libraries/DefaultValues.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
+import { CrossDomainUtils } from "../libraries/CrossDomainUtils.sol";
+import { WithdrawalVerifier } from "../libraries/WithdrawalVerifier.sol";
 
 /* Target contract dependencies */
 import { L2OutputOracle } from "../L1/L2OutputOracle.sol";
 import { OptimismPortal } from "../L1/OptimismPortal.sol";
 
-import { CrossDomainHashing } from "../libraries/Lib_CrossDomainHashing.sol";
+import { CrossDomainHashing } from "../libraries/CrossDomainHashing.sol";
 
 /* Target contract */
 import { L1CrossDomainMessenger } from "../L1/L1CrossDomainMessenger.sol";
@@ -74,7 +74,7 @@ contract L1CrossDomainMessenger_Test is Messenger_Initializer {
             address(op),
             abi.encodeWithSelector(
                 OptimismPortal.depositTransaction.selector,
-                Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
+                PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
                 0,
                 100 + L1Messenger.baseGas(hex"ff"),
                 false,
@@ -93,7 +93,7 @@ contract L1CrossDomainMessenger_Test is Messenger_Initializer {
         vm.expectEmit(true, true, true, true);
         emit TransactionDeposited(
             AddressAliasHelper.applyL1ToL2Alias(address(L1Messenger)),
-            Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
+            PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER,
             0,
             0,
             100 + L1Messenger.baseGas(hex"ff"),
@@ -137,7 +137,7 @@ contract L1CrossDomainMessenger_Test is Messenger_Initializer {
     // relayMessage: should send a successful call to the target contract
     function test_L1MessengerRelayMessageSucceeds() external {
         address target = address(0xabcd);
-        address sender = Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
+        address sender = PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
 
         vm.expectCall(target, hex"1111");
 
@@ -171,7 +171,7 @@ contract L1CrossDomainMessenger_Test is Messenger_Initializer {
     function test_L1MessengerRelayMessageToSystemContract() external {
         // set the target to be the OptimismPortal
         address target = address(op);
-        address sender = Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
+        address sender = PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
         bytes memory message = hex"1111";
 
         // set the value of op.l2Sender() to be the L2 Cross Domain Messenger.
@@ -189,7 +189,7 @@ contract L1CrossDomainMessenger_Test is Messenger_Initializer {
         vm.expectRevert("xDomainMessageSender is not set");
         L1Messenger.xDomainMessageSender();
 
-        address sender = Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
+        address sender = PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER;
 
         uint256 senderSlotIndex = 51;
         bytes32 slotValue = vm.load(address(op), bytes32(senderSlotIndex));

packages/contracts-bedrock/contracts/test/L1StandardBridge.t.sol

@@ -5,7 +5,7 @@ import { Bridge_Initializer } from "./CommonTest.t.sol";
 import { StandardBridge } from "../universal/StandardBridge.sol";
 import { L2StandardBridge } from "../L2/L2StandardBridge.sol";
 import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { stdStorage, StdStorage } from "forge-std/Test.sol";
@@ -25,12 +25,12 @@ contract L1StandardBridge_Test is Bridge_Initializer {
 
         assertEq(
             address(L1Bridge.otherBridge()),
-            Lib_PredeployAddresses.L2_STANDARD_BRIDGE
+            PredeployAddresses.L2_STANDARD_BRIDGE
         );
 
         assertEq(
             address(L2Bridge),
-            Lib_PredeployAddresses.L2_STANDARD_BRIDGE
+            PredeployAddresses.L2_STANDARD_BRIDGE
         );
     }
 

packages/contracts-bedrock/contracts/test/L2CrossDomainMessenger.t.sol

@@ -3,14 +3,14 @@ pragma solidity 0.8.10;
 
 import { Messenger_Initializer } from "./CommonTest.t.sol";
 
-import { Lib_CrossDomainUtils } from "../libraries/Lib_CrossDomainUtils.sol";
+import { CrossDomainUtils } from "../libraries/CrossDomainUtils.sol";
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
 import { L2ToL1MessagePasser } from "../L2/L2ToL1MessagePasser.sol";
 import { L2OutputOracle } from "../L1/L2OutputOracle.sol";
 import { L2CrossDomainMessenger } from "../L2/L2CrossDomainMessenger.sol";
 import { L1CrossDomainMessenger } from "../L1/L1CrossDomainMessenger.sol";
-import { CrossDomainHashing } from "../libraries/Lib_CrossDomainHashing.sol";
-import { Lib_DefaultValues } from "../libraries/Lib_DefaultValues.sol";
+import { CrossDomainHashing } from "../libraries/CrossDomainHashing.sol";
+import { DefaultValues } from "../libraries/DefaultValues.sol";
 
 contract L2CrossDomainMessenger_Test is Messenger_Initializer {
     // Receiver address for testing

packages/contracts-bedrock/contracts/test/L2StandardBridge.t.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.10;
 import { Bridge_Initializer } from "./CommonTest.t.sol";
 import { stdStorage, StdStorage } from "forge-std/Test.sol";
 import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 import { console } from "forge-std/console.sol";
 
 contract L2StandardBridge_Test is Bridge_Initializer {
@@ -52,7 +52,7 @@ contract L2StandardBridge_Test is Bridge_Initializer {
         vm.expectRevert("ETH withdrawals must include sufficient ETH value.");
         vm.prank(alice, alice);
         L2Bridge.withdraw(
-            address(Lib_PredeployAddresses.OVM_ETH),
+            address(PredeployAddresses.LEGACY_ERC20_ETH),
             100,
             1000,
             hex""

packages/contracts-bedrock/contracts/test/L2ToL1MessagePasser.t.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.10;
 
 import { CommonTest } from "./CommonTest.t.sol";
 import { L2ToL1MessagePasser } from "../L2/L2ToL1MessagePasser.sol";
-import { WithdrawalVerifier } from "../libraries/Lib_WithdrawalVerifier.sol";
+import { WithdrawalVerifier } from "../libraries/WithdrawalVerifier.sol";
 
 contract L2ToL1MessagePasserTest is CommonTest {
     L2ToL1MessagePasser messagePasser;

packages/contracts-bedrock/contracts/test/OVM_ETH.t.sol → packages/contracts-bedrock/contracts/test/LegacyERC20ETH.t.sol

@@ -2,14 +2,14 @@
 pragma solidity ^0.8.9;
 
 import { CommonTest } from "./CommonTest.t.sol";
-import { OVM_ETH } from "../L2/OVM_ETH.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { LegacyERC20ETH } from "../legacy/LegacyERC20ETH.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
-contract OVM_ETH_Test is CommonTest {
-    OVM_ETH eth;
+contract LegacyERC20ETH_Test is CommonTest {
+    LegacyERC20ETH eth;
 
     function setUp() external {
-        eth = new OVM_ETH();
+        eth = new LegacyERC20ETH();
     }
 
     function test_metadata() external {
@@ -19,42 +19,42 @@ contract OVM_ETH_Test is CommonTest {
     }
 
     function test_crossDomain() external {
-        assertEq(eth.l2Bridge(), Lib_PredeployAddresses.L2_STANDARD_BRIDGE);
+        assertEq(eth.l2Bridge(), PredeployAddresses.L2_STANDARD_BRIDGE);
         assertEq(eth.l1Token(), address(0));
     }
 
     function test_transfer() external {
-        vm.expectRevert("OVM_ETH: transfer is disabled");
+        vm.expectRevert("LegacyERC20ETH: transfer is disabled");
         eth.transfer(alice, 100);
     }
 
     function test_approve() external {
-        vm.expectRevert("OVM_ETH: approve is disabled");
+        vm.expectRevert("LegacyERC20ETH: approve is disabled");
         eth.approve(alice, 100);
     }
 
     function test_transferFrom() external {
-        vm.expectRevert("OVM_ETH: transferFrom is disabled");
+        vm.expectRevert("LegacyERC20ETH: transferFrom is disabled");
         eth.transferFrom(bob, alice, 100);
     }
 
     function test_increaseAllowance() external {
-        vm.expectRevert("OVM_ETH: increaseAllowance is disabled");
+        vm.expectRevert("LegacyERC20ETH: increaseAllowance is disabled");
         eth.increaseAllowance(alice, 100);
     }
 
     function test_decreaseAllowance() external {
-        vm.expectRevert("OVM_ETH: decreaseAllowance is disabled");
+        vm.expectRevert("LegacyERC20ETH: decreaseAllowance is disabled");
         eth.decreaseAllowance(alice, 100);
     }
 
     function test_mint() external {
-        vm.expectRevert("OVM_ETH: mint is disabled");
+        vm.expectRevert("LegacyERC20ETH: mint is disabled");
         eth.mint(alice, 100);
     }
 
     function test_burn() external {
-        vm.expectRevert("OVM_ETH: burn is disabled");
+        vm.expectRevert("LegacyERC20ETH: burn is disabled");
         eth.burn(alice, 100);
     }
 }

packages/contracts-bedrock/contracts/test/OptimismMintableTokenFactory.t.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.10;
 
 import { Bridge_Initializer } from "./CommonTest.t.sol";
-import { LibRLP } from "./Lib_RLP.t.sol";
+import { LibRLP } from "./RLP.t.sol";
 
 contract OptimismMintableTokenFactory_Test is Bridge_Initializer {
     event StandardL2TokenCreated(address indexed _remoteToken, address indexed _localToken);

packages/contracts-bedrock/contracts/test/OptimismPortal.t.sol

@@ -6,7 +6,7 @@ import { Portal_Initializer, CommonTest, NextImpl } from "./CommonTest.t.sol";
 import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
 import { L2OutputOracle } from "../L1/L2OutputOracle.sol";
 import { OptimismPortal } from "../L1/OptimismPortal.sol";
-import { WithdrawalVerifier } from "../libraries/Lib_WithdrawalVerifier.sol";
+import { WithdrawalVerifier } from "../libraries/WithdrawalVerifier.sol";
 import { Proxy } from "../universal/Proxy.sol";
 
 contract OptimismPortal_Test is Portal_Initializer {

packages/contracts-bedrock/contracts/test/ProxyAdmin.t.sol

@@ -6,17 +6,17 @@ import { Proxy } from "../universal/Proxy.sol";
 import { ProxyAdmin } from "../universal/ProxyAdmin.sol";
 import { SimpleStorage } from "./Proxy.t.sol";
 import { L1ChugSplashProxy } from "../legacy/L1ChugSplashProxy.sol";
-import { Lib_ResolvedDelegateProxy } from "../legacy/Lib_ResolvedDelegateProxy.sol";
-import { Lib_AddressManager } from "../legacy/Lib_AddressManager.sol";
+import { ResolvedDelegateProxy } from "../legacy/ResolvedDelegateProxy.sol";
+import { AddressManager } from "../legacy/AddressManager.sol";
 
 contract ProxyAdmin_Test is Test {
     address alice = address(64);
 
     Proxy proxy;
     L1ChugSplashProxy chugsplash;
-    Lib_ResolvedDelegateProxy resolved;
+    ResolvedDelegateProxy resolved;
 
-    Lib_AddressManager addressManager;
+    AddressManager addressManager;
 
     ProxyAdmin admin;
 
@@ -31,22 +31,22 @@ contract ProxyAdmin_Test is Test {
         // Deploy the legacy L1ChugSplashProxy with the admin as the owner
         chugsplash = new L1ChugSplashProxy(address(admin));
 
-        // Deploy the legacy Lib_AddressManager
-        addressManager = new Lib_AddressManager();
+        // Deploy the legacy AddressManager
+        addressManager = new AddressManager();
         // The proxy admin must be the new owner of the address manager
         addressManager.transferOwnership(address(admin));
-        // Deploy a legacy Lib_ResolvedDelegateProxy with the name `a`.
-        // Whatever `a` is set to in Lib_AddressManager will be the address
+        // Deploy a legacy ResolvedDelegateProxy with the name `a`.
+        // Whatever `a` is set to in AddressManager will be the address
         // that is used for the implementation.
-        resolved = new Lib_ResolvedDelegateProxy(address(addressManager), "a");
+        resolved = new ResolvedDelegateProxy(address(addressManager), "a");
 
         // Impersonate alice for setting up the admin.
         vm.startPrank(alice);
         // Set the address of the address manager in the admin so that it
         // can resolve the implementation address of legacy
-        // Lib_ResolvedDelegateProxy based proxies.
+        // ResolvedDelegateProxy based proxies.
         admin.setAddressManager(addressManager);
-        // Set the reverse lookup of the Lib_ResolvedDelegateProxy
+        // Set the reverse lookup of the ResolvedDelegateProxy
         // proxy
         admin.setImplementationName(address(resolved), "a");
 
@@ -70,7 +70,7 @@ contract ProxyAdmin_Test is Test {
 
     function test_onlyOwnerSetAddressManager() external {
         vm.expectRevert("UNAUTHORIZED");
-        admin.setAddressManager(Lib_AddressManager((address(0))));
+        admin.setAddressManager(AddressManager((address(0))));
     }
 
     function test_onlyOwnerSetImplementationName() external {

packages/contracts-bedrock/contracts/test/Lib_RLPReader.t.sol → packages/contracts-bedrock/contracts/test/RLPReader.t.sol

 // SPDX-License-Identifier: Unlicense
 pragma solidity >=0.8.0;
 
-import { Lib_RLPReader } from "../libraries/rlp/Lib_RLPReader.sol";
+import { RLPReader } from "../libraries/rlp/RLPReader.sol";
 import { CommonTest } from "./CommonTest.t.sol";
 
-contract Lib_RLPReader_Test is CommonTest {
+contract RLPReader_Test is CommonTest {
     function testReadBool() external {
         assertEq(
-            Lib_RLPReader.readBool(hex"01"),
+            RLPReader.readBool(hex"01"),
             true
         );
 
         assertEq(
-            Lib_RLPReader.readBool(hex"00"),
+            RLPReader.readBool(hex"00"),
             false
         );
     }
 
     function test_readBoolInvalidValue() external {
-        vm.expectRevert("Lib_RLPReader: Invalid RLP boolean value, must be 0 or 1");
-        Lib_RLPReader.readBool(hex"02");
+        vm.expectRevert("RLPReader: Invalid RLP boolean value, must be 0 or 1");
+        RLPReader.readBool(hex"02");
     }
 
     function test_readBoolLargeInput() external {
         vm.expectRevert("Invalid RLP boolean value.");
-        Lib_RLPReader.readBool(hex"0101");
+        RLPReader.readBool(hex"0101");
     }
 
     function test_readAddress() external {
         assertEq(
-            Lib_RLPReader.readAddress(hex"941212121212121212121212121212121212121212"),
+            RLPReader.readAddress(hex"941212121212121212121212121212121212121212"),
             address(0x1212121212121212121212121212121212121212)
         );
     }
 
     function test_readAddressSmall() external {
         assertEq(
-            Lib_RLPReader.readAddress(hex"12"),
+            RLPReader.readAddress(hex"12"),
             address(0)
         );
     }
 
     function test_readAddressTooLarge() external {
         vm.expectRevert("Invalid RLP address value.");
-        Lib_RLPReader.readAddress(hex"94121212121212121212121212121212121212121212121212");
+        RLPReader.readAddress(hex"94121212121212121212121212121212121212121212121212");
     }
 
     function test_readAddressTooShort() external {
         vm.expectRevert("Invalid RLP address value.");
-        Lib_RLPReader.readAddress(hex"94121212121212121212121212");
+        RLPReader.readAddress(hex"94121212121212121212121212");
     }
 
     function test_readBytes_bytestring00() external {
         assertEq(
-            Lib_RLPReader.readBytes(hex"00"),
+            RLPReader.readBytes(hex"00"),
             hex"00"
         );
     }
 
     function test_readBytes_bytestring01() external {
         assertEq(
-            Lib_RLPReader.readBytes(hex"01"),
+            RLPReader.readBytes(hex"01"),
             hex"01"
         );
     }
 
     function test_readBytes_bytestring7f() external {
         assertEq(
-            Lib_RLPReader.readBytes(hex"7f"),
+            RLPReader.readBytes(hex"7f"),
             hex"7f"
         );
     }
 
     function test_readBytes_revertListItem() external {
         vm.expectRevert("Invalid RLP bytes value.");
-        Lib_RLPReader.readBytes(hex"c7c0c1c0c3c0c1c0");
+        RLPReader.readBytes(hex"c7c0c1c0c3c0c1c0");
     }
 
     function test_readBytes_invalidStringLength() external {
         vm.expectRevert("Invalid RLP long string length.");
-        Lib_RLPReader.readBytes(hex"b9");
+        RLPReader.readBytes(hex"b9");
     }
 
     function test_readBytes_invalidListLength() external {
         vm.expectRevert("Invalid RLP long list length.");
-        Lib_RLPReader.readBytes(hex"ff");
+        RLPReader.readBytes(hex"ff");
     }
 
     function test_readBytes32_revertOnList() external {
         vm.expectRevert("Invalid RLP bytes32 value.");
-        Lib_RLPReader.readBytes32(hex"c7c0c1c0c3c0c1c0");
+        RLPReader.readBytes32(hex"c7c0c1c0c3c0c1c0");
     }
 
     function test_readBytes32_revertOnTooLong() external {
         vm.expectRevert("Invalid RLP bytes32 value.");
-        Lib_RLPReader.readBytes32(hex"11110000000000000000000000000000000000000000000000000000000000000000");
+        RLPReader.readBytes32(hex"11110000000000000000000000000000000000000000000000000000000000000000");
     }
 
     function test_readString_emptyString() external {
         assertEq(
-            Lib_RLPReader.readString(hex"80"),
+            RLPReader.readString(hex"80"),
             hex""
         );
     }
 
     function test_readString_shortString() external {
         assertEq(
-            Lib_RLPReader.readString(hex"83646f67"),
+            RLPReader.readString(hex"83646f67"),
             "dog"
         );
     }
 
     function test_readString_shortString2() external {
         assertEq(
-            Lib_RLPReader.readString(hex"b74c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c69"),
+            RLPReader.readString(hex"b74c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c69"),
             "Lorem ipsum dolor sit amet, consectetur adipisicing eli"
         );
     }
 
     function test_readString_longString() external {
         assertEq(
-            Lib_RLPReader.readString(hex"b8384c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c6974"),
+            RLPReader.readString(hex"b8384c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c6974"),
             "Lorem ipsum dolor sit amet, consectetur adipisicing elit"
         );
     }
 
     function test_readString_longString2() external {
         assertEq(
-            Lib_RLPReader.readString(hex"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"),
+            RLPReader.readString(hex"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"),
             "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur mauris magna, suscipit sed vehicula non, iaculis faucibus tortor. Proin suscipit ultricies malesuada. Duis tortor elit, dictum quis tristique eu, ultrices at risus. Morbi a est imperdiet mi ullamcorper aliquet suscipit nec lorem. Aenean quis leo mollis, vulputate elit varius, consequat enim. Nulla ultrices turpis justo, et posuere urna consectetur nec. Proin non convallis metus. Donec tempor ipsum in mauris congue sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Suspendisse convallis sem vel massa faucibus, eget lacinia lacus tempor. Nulla quis ultricies purus. Proin auctor rhoncus nibh condimentum mollis. Aliquam consequat enim at metus luctus, a eleifend purus egestas. Curabitur at nibh metus. Nam bibendum, neque at auctor tristique, lorem libero aliquet arcu, non interdum tellus lectus sit amet eros. Cras rhoncus, metus ac ornare cursus, dolor justo ultrices metus, at ullamcorper volutpat"
         );
     }
 
     function test_readUint256_zero() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"80"),
+            RLPReader.readUint256(hex"80"),
             0
         );
     }
 
     function test_readUint256_smallInt() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"01"),
+            RLPReader.readUint256(hex"01"),
             1
         );
     }
 
     function test_readUint256_smallInt2() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"10"),
+            RLPReader.readUint256(hex"10"),
             16
         );
     }
 
     function test_readUint256_smallInt3() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"4f"),
+            RLPReader.readUint256(hex"4f"),
             79
         );
     }
 
     function test_readUint256_smallInt4() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"7f"),
+            RLPReader.readUint256(hex"7f"),
             127
         );
     }
 
     function test_readUint256_mediumInt1() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"8180"),
+            RLPReader.readUint256(hex"8180"),
             128
         );
     }
 
     function test_readUint256_mediumInt2() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"8203e8"),
+            RLPReader.readUint256(hex"8203e8"),
             1000
         );
     }
 
     function test_readUint256_mediumInt3() external {
         assertEq(
-            Lib_RLPReader.readUint256(hex"830186a0"),
+            RLPReader.readUint256(hex"830186a0"),
             100000
         );
     }
 
     function test_readList_empty() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"c0");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"c0");
         assertEq(list.length, 0);
     }
 
     function test_readList_stringList() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"cc83646f6783676f6483636174");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"cc83646f6783676f6483636174");
         assertEq(list.length, 3);
-        assertEq(Lib_RLPReader.readString(list[0]), Lib_RLPReader.readString(hex"83646f67"));
-        assertEq(Lib_RLPReader.readString(list[1]), Lib_RLPReader.readString(hex"83676f64"));
-        assertEq(Lib_RLPReader.readString(list[2]), Lib_RLPReader.readString(hex"83636174"));
+        assertEq(RLPReader.readString(list[0]), RLPReader.readString(hex"83646f67"));
+        assertEq(RLPReader.readString(list[1]), RLPReader.readString(hex"83676f64"));
+        assertEq(RLPReader.readString(list[2]), RLPReader.readString(hex"83636174"));
     }
 
     function test_readList_multiList() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"c6827a77c10401");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"c6827a77c10401");
         assertEq(list.length, 3);
 
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"827a77");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"c104");
-        assertEq(Lib_RLPReader.readRawBytes(list[2]), hex"01");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"827a77");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"c104");
+        assertEq(RLPReader.readRawBytes(list[2]), hex"01");
     }
 
     function test_readList_shortListMax1() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"f784617364668471776572847a78637684617364668471776572847a78637684617364668471776572847a78637684617364668471776572");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"f784617364668471776572847a78637684617364668471776572847a78637684617364668471776572847a78637684617364668471776572");
 
         assertEq(list.length, 11);
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"8461736466");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"8471776572");
-        assertEq(Lib_RLPReader.readRawBytes(list[2]), hex"847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[3]), hex"8461736466");
-        assertEq(Lib_RLPReader.readRawBytes(list[4]), hex"8471776572");
-        assertEq(Lib_RLPReader.readRawBytes(list[5]), hex"847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[6]), hex"8461736466");
-        assertEq(Lib_RLPReader.readRawBytes(list[7]), hex"8471776572");
-        assertEq(Lib_RLPReader.readRawBytes(list[8]), hex"847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[9]), hex"8461736466");
-        assertEq(Lib_RLPReader.readRawBytes(list[10]), hex"8471776572");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"8461736466");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"8471776572");
+        assertEq(RLPReader.readRawBytes(list[2]), hex"847a786376");
+        assertEq(RLPReader.readRawBytes(list[3]), hex"8461736466");
+        assertEq(RLPReader.readRawBytes(list[4]), hex"8471776572");
+        assertEq(RLPReader.readRawBytes(list[5]), hex"847a786376");
+        assertEq(RLPReader.readRawBytes(list[6]), hex"8461736466");
+        assertEq(RLPReader.readRawBytes(list[7]), hex"8471776572");
+        assertEq(RLPReader.readRawBytes(list[8]), hex"847a786376");
+        assertEq(RLPReader.readRawBytes(list[9]), hex"8461736466");
+        assertEq(RLPReader.readRawBytes(list[10]), hex"8471776572");
     }
 
     function test_readList_longList1() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"f840cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"f840cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376");
 
         assertEq(list.length, 4);
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"cf84617364668471776572847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"cf84617364668471776572847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[2]), hex"cf84617364668471776572847a786376");
-        assertEq(Lib_RLPReader.readRawBytes(list[3]), hex"cf84617364668471776572847a786376");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"cf84617364668471776572847a786376");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"cf84617364668471776572847a786376");
+        assertEq(RLPReader.readRawBytes(list[2]), hex"cf84617364668471776572847a786376");
+        assertEq(RLPReader.readRawBytes(list[3]), hex"cf84617364668471776572847a786376");
     }
 
     function test_readList_longList2() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"f90200cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"f90200cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376cf84617364668471776572847a786376");
         assertEq(list.length, 32);
 
         for (uint256 i = 0; i < 32; i++) {
-            assertEq(Lib_RLPReader.readRawBytes(list[i]), hex"cf84617364668471776572847a786376");
+            assertEq(RLPReader.readRawBytes(list[i]), hex"cf84617364668471776572847a786376");
         }
     }
 
     function test_readList_listOfLists() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"c4c2c0c0c0");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"c4c2c0c0c0");
         assertEq(list.length, 2);
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"c2c0c0");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"c0");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"c2c0c0");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"c0");
     }
 
     function test_readList_listOfLists2() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"c7c0c1c0c3c0c1c0");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"c7c0c1c0c3c0c1c0");
         assertEq(list.length, 3);
 
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"c0");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"c1c0");
-        assertEq(Lib_RLPReader.readRawBytes(list[2]), hex"c3c0c1c0");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"c0");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"c1c0");
+        assertEq(RLPReader.readRawBytes(list[2]), hex"c3c0c1c0");
     }
 
     function test_readList_dictTest1() external {
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"ecca846b6579318476616c31ca846b6579328476616c32ca846b6579338476616c33ca846b6579348476616c34");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"ecca846b6579318476616c31ca846b6579328476616c32ca846b6579338476616c33ca846b6579348476616c34");
         assertEq(list.length, 4);
 
-        assertEq(Lib_RLPReader.readRawBytes(list[0]), hex"ca846b6579318476616c31");
-        assertEq(Lib_RLPReader.readRawBytes(list[1]), hex"ca846b6579328476616c32");
-        assertEq(Lib_RLPReader.readRawBytes(list[2]), hex"ca846b6579338476616c33");
-        assertEq(Lib_RLPReader.readRawBytes(list[3]), hex"ca846b6579348476616c34");
+        assertEq(RLPReader.readRawBytes(list[0]), hex"ca846b6579318476616c31");
+        assertEq(RLPReader.readRawBytes(list[1]), hex"ca846b6579328476616c32");
+        assertEq(RLPReader.readRawBytes(list[2]), hex"ca846b6579338476616c33");
+        assertEq(RLPReader.readRawBytes(list[3]), hex"ca846b6579348476616c34");
     }
 
     function test_readList_invalidShortList() external {
         vm.expectRevert("Invalid RLP short list.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"efdebd");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"efdebd");
     }
 
     function test_readList_longStringLength() external {
         vm.expectRevert("Invalid RLP short list.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"efb83600");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"efb83600");
     }
 
     function test_readList_notLongEnough() external {
         vm.expectRevert("Invalid RLP short list.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"efdebdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"efdebdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
     }
 
     function test_readList_int32Overflow() external {
         vm.expectRevert("Invalid RLP long string.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"bf0f000000000000021111");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"bf0f000000000000021111");
     }
 
     function test_readList_int32Overflow2() external {
         vm.expectRevert("Invalid RLP long list.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"ff0f000000000000021111");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"ff0f000000000000021111");
     }
 
     function test_readList_incorrectLengthInArray() external {
         vm.expectRevert("Invalid RLP list value.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"b9002100dc2b275d0f74e8a53e6f4ec61b27f24278820be3f82ea2110e582081b0565df0");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"b9002100dc2b275d0f74e8a53e6f4ec61b27f24278820be3f82ea2110e582081b0565df0");
     }
 
     function test_readList_leadingZerosInLongLengthArray1() external {
         vm.expectRevert("Invalid RLP list value.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"b90040000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"b90040000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
     }
 
     function test_readList_leadingZerosInLongLengthArray2() external {
         vm.expectRevert("Invalid RLP list value.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"b800");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"b800");
     }
 
     function test_readList_leadingZerosInLongLengthList1() external {
         vm.expectRevert("Provided RLP list exceeds max list length.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"fb00000040000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"fb00000040000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
     }
 
     function test_readList_nonOptimalLongLengthArray1() external {
         vm.expectRevert("Invalid RLP list value.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"b81000112233445566778899aabbccddeeff");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"b81000112233445566778899aabbccddeeff");
     }
 
     function test_readList_nonOptimalLongLengthArray2() external {
         vm.expectRevert("Invalid RLP list value.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"b801ff");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"b801ff");
     }
 
     function test_readList_invalidValue() external {
         vm.expectRevert("Invalid RLP short string.");
-        Lib_RLPReader.RLPItem[] memory list = Lib_RLPReader.readList(hex"91");
+        RLPReader.RLPItem[] memory list = RLPReader.readList(hex"91");
     }
 }

packages/contracts-bedrock/contracts/test/SequencerFeeVault.t.sol

@@ -5,23 +5,23 @@ import { Bridge_Initializer } from "./CommonTest.t.sol";
 
 import { SequencerFeeVault } from "../L2/SequencerFeeVault.sol";
 import { L2StandardBridge } from "../L2/L2StandardBridge.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 contract SequencerFeeVault_Test is Bridge_Initializer {
     SequencerFeeVault vault =
-        SequencerFeeVault(payable(Lib_PredeployAddresses.SEQUENCER_FEE_WALLET));
+        SequencerFeeVault(payable(PredeployAddresses.SEQUENCER_FEE_WALLET));
     address constant recipient = address(256);
 
     function setUp() public override {
         super.setUp();
 
         vm.etch(
-            Lib_PredeployAddresses.SEQUENCER_FEE_WALLET,
+            PredeployAddresses.SEQUENCER_FEE_WALLET,
             address(new SequencerFeeVault()).code
         );
 
         vm.store(
-            Lib_PredeployAddresses.SEQUENCER_FEE_WALLET,
+            PredeployAddresses.SEQUENCER_FEE_WALLET,
             bytes32(uint256(0)),
             bytes32(uint256(uint160(recipient)))
         );
@@ -69,10 +69,10 @@ contract SequencerFeeVault_Test is Bridge_Initializer {
         vm.deal(address(vault), vault.MIN_WITHDRAWAL_AMOUNT() + 1);
 
         vm.expectCall(
-            Lib_PredeployAddresses.L2_STANDARD_BRIDGE,
+            PredeployAddresses.L2_STANDARD_BRIDGE,
             abi.encodeWithSelector(
                 L2StandardBridge.withdrawTo.selector,
-                Lib_PredeployAddresses.OVM_ETH,
+                PredeployAddresses.LEGACY_ERC20_ETH,
                 vault.l1FeeWallet(),
                 address(vault).balance,
                 0,

packages/contracts-bedrock/contracts/universal/CrossDomainMessenger.sol

@@ -11,8 +11,8 @@ import {
     ReentrancyGuardUpgradeable
 } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import { ExcessivelySafeCall } from "excessively-safe-call/src/ExcessivelySafeCall.sol";
-import { Lib_DefaultValues } from "../libraries/Lib_DefaultValues.sol";
-import { CrossDomainHashing } from "../libraries/Lib_CrossDomainHashing.sol";
+import { DefaultValues } from "../libraries/DefaultValues.sol";
+import { CrossDomainHashing } from "../libraries/CrossDomainHashing.sol";
 
 /**
  * @title CrossDomainMessenger
@@ -153,7 +153,7 @@ abstract contract CrossDomainMessenger is
      */
     function xDomainMessageSender() external view returns (address) {
         require(
-            xDomainMsgSender != Lib_DefaultValues.DEFAULT_XDOMAIN_SENDER,
+            xDomainMsgSender != DefaultValues.DEFAULT_XDOMAIN_SENDER,
             "xDomainMessageSender is not set"
         );
 
@@ -287,7 +287,7 @@ abstract contract CrossDomainMessenger is
             0,
             _message
         );
-        xDomainMsgSender = Lib_DefaultValues.DEFAULT_XDOMAIN_SENDER;
+        xDomainMsgSender = DefaultValues.DEFAULT_XDOMAIN_SENDER;
 
         if (success == true) {
             successfulMessages[versionedHash] = true;
@@ -312,7 +312,7 @@ abstract contract CrossDomainMessenger is
     function _initialize(address _otherMessenger, address[] memory _blockedSystemAddresses)
         internal
     {
-        xDomainMsgSender = Lib_DefaultValues.DEFAULT_XDOMAIN_SENDER;
+        xDomainMsgSender = DefaultValues.DEFAULT_XDOMAIN_SENDER;
         otherMessenger = _otherMessenger;
 
         for (uint256 i = 0; i < _blockedSystemAddresses.length; i++) {

packages/contracts-bedrock/contracts/universal/OptimismMintableTokenFactory.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.9;
 
 /* Contract Imports */
 import { OptimismMintableERC20 } from "../universal/OptimismMintableERC20.sol";
-import { Lib_PredeployAddresses } from "../libraries/Lib_PredeployAddresses.sol";
+import { PredeployAddresses } from "../libraries/PredeployAddresses.sol";
 
 /**
  * @custom:proxied

packages/contracts-bedrock/contracts/universal/ProxyAdmin.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.9;
 
 import { Owned } from "@rari-capital/solmate/src/auth/Owned.sol";
 import { Proxy } from "./Proxy.sol";
-import { Lib_AddressManager } from "../legacy/Lib_AddressManager.sol";
+import { AddressManager } from "../legacy/AddressManager.sol";
 import { L1ChugSplashProxy } from "../legacy/L1ChugSplashProxy.sol";
 
 /**
@@ -65,7 +65,7 @@ contract ProxyAdmin is Owned {
      * @notice The address of the address manager, this is required to manage the
      *         ResolvedDelegateProxy type.
      */
-    Lib_AddressManager public addressManager;
+    AddressManager public addressManager;
 
     /**
      * @custom:legacy
@@ -106,7 +106,7 @@ contract ProxyAdmin is Owned {
      *
      * @param _address Address of the AddressManager.
      */
-    function setAddressManager(Lib_AddressManager _address) external onlyOwner {
+    function setAddressManager(AddressManager _address) external onlyOwner {
         addressManager = _address;
     }
 

packages/contracts-bedrock/scripts/storage-snapshot.sh

@@ -21,7 +21,7 @@ contracts=(
   L2CrossDomainMessenger
   L2StandardBridge
   L2ToL1MessagePasser
-  OVM_ETH
+  LegacyERC20ETH
   SequencerFeeVault
   WETH9
   ProxyAdmin

packages/contracts-bedrock/src/constants.ts

@@ -16,7 +16,7 @@ export const predeploys = {
   OptimismMintableTokenFactory: '0x4200000000000000000000000000000000000012',
   L1BlockNumber: '0x4200000000000000000000000000000000000013',
   L1Block: '0x4200000000000000000000000000000000000015',
-  OVM_ETH: '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
+  LegacyERC20ETH: '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
   WETH9: '0x4200000000000000000000000000000000000006',
   GovernanceToken: '0x4200000000000000000000000000000000000042',
 }

packages/contracts-bedrock/tasks/genesis-l2.ts

@@ -112,7 +112,7 @@ task('genesis-l2', 'create a genesis config')
         hash: deployConfig.l1BlockInitialHash,
         sequenceNumber: deployConfig.l1BlockInitialSequenceNumber,
       },
-      OVM_ETH: {
+      LegacyERC20ETH: {
         bridge: predeploys.L2StandardBridge,
         remoteToken: ethers.constants.AddressZero,
         _name: 'Ether',
@@ -150,9 +150,9 @@ task('genesis-l2', 'create a genesis config')
         ethers.utils.hexConcat([prefix, num])
       )
 
-      // There is no proxy at OVM_ETH or the GovernanceToken
+      // There is no proxy at LegacyERC20ETH or the GovernanceToken
       if (
-        addr === ethers.utils.getAddress(predeploys.OVM_ETH) ||
+        addr === ethers.utils.getAddress(predeploys.LegacyERC20ETH) ||
         addr === ethers.utils.getAddress(predeploys.GovernanceToken)
       ) {
         continue
@@ -236,7 +236,7 @@ task('genesis-l2', 'create a genesis config')
       const artifact = await hre.artifacts.readArtifact(name)
       assertEvenLength(artifact.deployedBytecode)
 
-      const allocAddr = name === 'OVM_ETH' ? addr : toCodeAddr(addr)
+      const allocAddr = name === 'LegacyERC20ETH' ? addr : toCodeAddr(addr)
       assertEvenLength(allocAddr)
 
       alloc[allocAddr] = {