Merge branch 'develop' into feat/l1-devnet-fund-dev-accounts

op-challenger/fault/alphabet_provider.go

+package fault
+
+import (
+	"math/big"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// AlphabetProvider is a [TraceProvider] that provides claims for specific
+// indices in the given trace.
+type AlphabetProvider struct {
+	state  []string
+	maxLen uint64
+}
+
+// NewAlphabetProvider returns a new [AlphabetProvider].
+func NewAlphabetProvider(state string, depth uint64) *AlphabetProvider {
+	return &AlphabetProvider{
+		state:  strings.Split(state, ""),
+		maxLen: (1 << depth),
+	}
+}
+
+// Get returns the claim value at the given index in the trace.
+func (ap *AlphabetProvider) Get(i uint64) (common.Hash, error) {
+	// The index cannot be larger than the maximum index as computed by the depth.
+	if i >= ap.maxLen {
+		return common.Hash{}, ErrIndexTooLarge
+	}
+	// We extend the deepest hash to the maximum depth if the trace is not expansive.
+	if i >= uint64(len(ap.state)) {
+		return ap.Get(uint64(len(ap.state)) - 1)
+	}
+	return ap.ComputeAlphabetClaim(i), nil
+}
+
+// ComputeAlphabetClaim computes the claim for the given index in the trace.
+func (ap *AlphabetProvider) ComputeAlphabetClaim(i uint64) common.Hash {
+	concatenated := append(IndexToBytes(i), []byte(ap.state[i])...)
+	return common.BytesToHash(concatenated)
+}
+
+// IndexToBytes converts an index to a byte slice big endian
+func IndexToBytes(i uint64) []byte {
+	big := new(big.Int)
+	big.SetUint64(i)
+	return big.Bytes()
+}

op-challenger/fault/alphabet_provider_test.go

+package fault
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+// FuzzIndexToBytes tests the IndexToBytes function.
+func FuzzIndexToBytes(f *testing.F) {
+	f.Fuzz(func(t *testing.T, index uint64) {
+		translated := IndexToBytes(index)
+		original := new(big.Int)
+		original.SetBytes(translated)
+		require.Equal(t, original.Uint64(), index)
+	})
+}
+
+// TestComputeAlphabetClaim tests the ComputeAlphabetClaim function.
+func TestComputeAlphabetClaim(t *testing.T) {
+	ap := NewAlphabetProvider("abc", 2)
+	claim := ap.ComputeAlphabetClaim(0)
+	concatenated := append(IndexToBytes(0), []byte("a")...)
+	expected := common.BytesToHash(concatenated)
+	require.Equal(t, expected, claim)
+}
+
+// TestGet tests the Get function.
+func TestGet(t *testing.T) {
+	ap := NewAlphabetProvider("abc", 2)
+	claim, err := ap.Get(0)
+	require.NoError(t, err)
+	concatenated := append(IndexToBytes(0), []byte("a")...)
+	expected := common.BytesToHash(concatenated)
+	require.Equal(t, expected, claim)
+}
+
+// TestGet_IndexTooLarge tests the Get function with an index
+// greater than the number of indices: 2^depth - 1.
+func TestGet_IndexTooLarge(t *testing.T) {
+	ap := NewAlphabetProvider("abc", 2)
+	_, err := ap.Get(4)
+	require.ErrorIs(t, err, ErrIndexTooLarge)
+}
+
+// TestGet_Extends tests the Get function with an index that is larger
+// than the trace, but smaller than the maximum depth.
+func TestGet_Extends(t *testing.T) {
+	ap := NewAlphabetProvider("abc", 2)
+	claim, err := ap.Get(3)
+	require.NoError(t, err)
+	concatenated := append(IndexToBytes(2), []byte("c")...)
+	expected := common.BytesToHash(concatenated)
+	require.Equal(t, expected, claim)
+}

op-challenger/fault/types.go

@@ -13,8 +13,9 @@ var (
 
 // TraceProvider is a generic way to get a claim value at a specific
 // step in the trace.
+// The [AlphabetProvider] is a minimal implementation of this interface.
 type TraceProvider interface {
-	Get(i int) (common.Hash, error)
+	Get(i uint64) (common.Hash, error)
 }
 
 type Claim struct {

op-node/p2p/cli/load_config.go

@@ -174,7 +174,7 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 		return fmt.Errorf("failed to open discovery db: %w", err)
 	}
 
-	conf.Bootnodes = p2p.DefaultBootnodes
+	bootnodes := make([]*enode.Node, 0)
 	records := strings.Split(ctx.GlobalString(flags.Bootnodes.Name), ",")
 	for i, recordB64 := range records {
 		recordB64 = strings.TrimSpace(recordB64)
@@ -185,7 +185,12 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 		if err != nil {
 			return fmt.Errorf("bootnode record %d (of %d) is invalid: %q err: %w", i, len(records), recordB64, err)
 		}
-		conf.Bootnodes = append(conf.Bootnodes, nodeRecord)
+		bootnodes = append(bootnodes, nodeRecord)
+	}
+	if len(bootnodes) > 0 {
+		conf.Bootnodes = bootnodes
+	} else {
+		conf.Bootnodes = p2p.DefaultBootnodes
 	}
 
 	return nil

packages/contracts-bedrock/STYLE_GUIDE.md

@@ -10,8 +10,8 @@ with priority on the `L2OutputOracle` and `OptimismPortal`.
 
 #### Comments
 
-We use [Seaport](https://github.com/ProjectOpenSea/seaport/blob/main/contracts/Seaport.sol)-style comments with some minor modifications.
-Some basic rules:
+Optimism smart contracts follow the triple-slash [solidity natspec comment style](https://docs.soliditylang.org/en/develop/natspec-format.html#documentation-example)
+with additional rules. These are:
 
 - Always use `@notice` since it has the same general effect as `@dev` but avoids confusion about when to use one over the other.
 - Include a newline between `@notice` and the first `@param`.
@@ -28,13 +28,19 @@ We also have the following custom tags:
 #### Errors
 
 - Use `require` statements when making simple assertions.
-- Use `revert` if throwing an error where an assertion is not being made (no custom errors). See [here](https://github.com/ethereum-optimism/optimism/blob/861ae315a6db698a8c0adb1f8eab8311fd96be4c/packages/contracts-bedrock/contracts/L2/OVM_ETH.sol#L31) for an example of this in practice.
+- Use `revert(string)` if throwing an error where an assertion is not being made (no custom errors).
+  See [here](https://github.com/ethereum-optimism/optimism/blob/861ae315a6db698a8c0adb1f8eab8311fd96be4c/packages/contracts-bedrock/contracts/L2/OVM_ETH.sol#L31)
+  for an example of this in practice.
 - Error strings MUST have the format `"{ContractName}: {message}"` where `message` is a lower case string.
 
 #### Function Parameters
 
 - Function parameters should be prefixed with an underscore.
 
+#### Function Return Arguments
+
+- Arguments returned by functions should be suffixed with an underscore.
+
 #### Event Parameters
 
 - Event parameters should NOT be prefixed with an underscore.
@@ -42,16 +48,21 @@ We also have the following custom tags:
 #### Spacers
 
 We use spacer variables to account for old storage slots that are no longer being used.
-The name of a spacer variable MUST be in the format `spacer_<slot>_<offset>_<length>` where `<slot>` is the original storage slot number, `<offset>` is the original offset position within the storage slot, and `<length>` is the original size of the variable.
+The name of a spacer variable MUST be in the format `spacer_<slot>_<offset>_<length>` where
+`<slot>` is the original storage slot number, `<offset>` is the original offset position
+within the storage slot, and `<length>` is the original size of the variable.
 Spacers MUST be `private`.
 
 ### Proxy by Default
 
 All contracts should be assumed to live behind proxies (except in certain special circumstances).
 This means that new contracts MUST be built under the assumption of upgradeability.
-We use a minimal [`Proxy`](./contracts/universal/Proxy.sol) contract designed to be owned by a corresponding [`ProxyAdmin`](./contracts/universal/ProxyAdmin.sol) which follow the interfaces of OpenZeppelin's `Proxy` and `ProxyAdmin` contracts, respectively.
+We use a minimal [`Proxy`](./contracts/universal/Proxy.sol) contract designed to be owned by a
+corresponding [`ProxyAdmin`](./contracts/universal/ProxyAdmin.sol) which follow the interfaces
+of OpenZeppelin's `Proxy` and `ProxyAdmin` contracts, respectively.
 
-Unless explicitly discussed otherwise, you MUST include the following basic upgradeability pattern for each new implementation contract:
+Unless explicitly discussed otherwise, you MUST include the following basic upgradeability
+pattern for each new implementation contract:
 
 1. Extend OpenZeppelin's `Initializable` base contract.
 2. Include a `uint8 public constant VERSION = X` at the TOP of your contract.
@@ -60,11 +71,13 @@ Unless explicitly discussed otherwise, you MUST include the following basic upgr
 
 ### Versioning
 
-All (non-library and non-abstract) contracts MUST extend the `Semver` base contract which exposes a `version()` function that returns a semver-compliant version string.
-During the Bedrock development process the `Semver` value for all contracts SHOULD return `0.0.1` (this is not particularly important, but it's an easy standard to follow).
-When the initial Bedrock upgrade is released, the `Semver` value MUST be updated to `1.0.0`.
+All (non-library and non-abstract) contracts MUST extend the `Semver` base contract which
+exposes a `version()` function that returns a semver-compliant version string.
+
+Contracts must have a `Semver` of `1.0.0` or greater to be production ready. Contracts
+with `Semver` values less than `1.0.0` should only be used locally or on devnets.
 
-After the initial Bedrock upgrade, contracts MUST use the following versioning scheme:
+Additionally, contracts MUST use the following versioning scheme:
 
 - `patch` releases are to be used only for changes that do NOT modify contract bytecode (such as updating comments).
 - `minor` releases are to be used for changes that modify bytecode OR changes that expand the contract ABI provided that these changes do NOT break the existing interface.
@@ -72,7 +85,8 @@ After the initial Bedrock upgrade, contracts MUST use the following versioning s
 
 #### Exceptions
 
-We have made an exception to the `Semver` rule for the `WETH` contract to avoid making changes to a well-known, simple, and recognizable contract.
+We have made an exception to the `Semver` rule for the `WETH` contract to avoid
+making changes to a well-known, simple, and recognizable contract.
 
 ### Dependencies