Merge branch 'develop' into 08-23-feat_indexer_update_Dockerfile_to_run_indexer_all

op-chain-ops/safe/batch_file.go → op-chain-ops/safe/batch.go

@@ -4,46 +4,134 @@
 package safe
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"math/big"
+	"strings"
 
+	"golang.org/x/exp/maps"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
-// BatchFile represents a Safe tx-builder transaction.
-type BatchFile struct {
+// Batch represents a Safe tx-builder transaction.
+type Batch struct {
 	Version      string             `json:"version"`
 	ChainID      *big.Int           `json:"chainId"`
 	CreatedAt    uint64             `json:"createdAt"`
-	Meta         BatchFileMeta      `json:"meta"`
+	Meta         BatchMeta          `json:"meta"`
 	Transactions []BatchTransaction `json:"transactions"`
 }
 
+// AddCall will add a call to the batch. After a series of calls are
+// added to the batch, it can be serialized to JSON.
+func (b *Batch) AddCall(to common.Address, value *big.Int, sig string, args []any, iface abi.ABI) error {
+	// Attempt to pull out the signature from the top level methods.
+	// The abi package uses normalization that we do not want to be
+	// coupled to, so attempt to search for the raw name if the top
+	// level name is not found to handle overloading more gracefully.
+	method, ok := iface.Methods[sig]
+	if !ok {
+		for _, m := range iface.Methods {
+			if m.RawName == sig || m.Sig == sig {
+				method = m
+				ok = true
+			}
+		}
+	}
+	if !ok {
+		keys := maps.Keys(iface.Methods)
+		methods := strings.Join(keys, ",")
+		return fmt.Errorf("%s not found in abi, options are %s", sig, methods)
+	}
+
+	if len(args) != len(method.Inputs) {
+		return fmt.Errorf("requires %d inputs but got %d for %s", len(method.Inputs), len(args), method.RawName)
+	}
+
+	contractMethod := ContractMethod{
+		Name:    method.RawName,
+		Payable: method.Payable,
+	}
+
+	inputValues := make(map[string]string)
+	contractInputs := make([]ContractInput, 0)
+
+	for i, input := range method.Inputs {
+		contractInput, err := createContractInput(input, contractInputs)
+		if err != nil {
+			return err
+		}
+		contractMethod.Inputs = append(contractMethod.Inputs, contractInput...)
+
+		str, err := stringifyArg(args[i])
+		if err != nil {
+			return err
+		}
+		inputValues[input.Name] = str
+	}
+
+	encoded, err := method.Inputs.PackValues(args)
+	if err != nil {
+		return err
+	}
+	data := make([]byte, len(method.ID)+len(encoded))
+	copy(data, method.ID)
+	copy(data[len(method.ID):], encoded)
+
+	batchTransaction := BatchTransaction{
+		To:          to,
+		Value:       value,
+		Method:      contractMethod,
+		Data:        data,
+		InputValues: inputValues,
+	}
+
+	b.Transactions = append(b.Transactions, batchTransaction)
+
+	return nil
+}
+
+// Check will check the batch for errors
+func (b *Batch) Check() error {
+	for _, tx := range b.Transactions {
+		if err := tx.Check(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // bathcFileMarshaling is a helper type used for JSON marshaling.
-type batchFileMarshaling struct {
+type batchMarshaling struct {
 	Version      string             `json:"version"`
 	ChainID      string             `json:"chainId"`
 	CreatedAt    uint64             `json:"createdAt"`
-	Meta         BatchFileMeta      `json:"meta"`
+	Meta         BatchMeta          `json:"meta"`
 	Transactions []BatchTransaction `json:"transactions"`
 }
 
-// MarshalJSON will marshal a BatchFile to JSON.
-func (b *BatchFile) MarshalJSON() ([]byte, error) {
-	return json.Marshal(batchFileMarshaling{
+// MarshalJSON will marshal a Batch to JSON.
+func (b *Batch) MarshalJSON() ([]byte, error) {
+	batch := batchMarshaling{
 		Version:      b.Version,
-		ChainID:      b.ChainID.String(),
 		CreatedAt:    b.CreatedAt,
 		Meta:         b.Meta,
 		Transactions: b.Transactions,
-	})
+	}
+	if b.ChainID != nil {
+		batch.ChainID = b.ChainID.String()
+	}
+	return json.Marshal(batch)
 }
 
-// UnmarshalJSON will unmarshal a BatchFile from JSON.
-func (b *BatchFile) UnmarshalJSON(data []byte) error {
-	var bf batchFileMarshaling
+// UnmarshalJSON will unmarshal a Batch from JSON.
+func (b *Batch) UnmarshalJSON(data []byte) error {
+	var bf batchMarshaling
 	if err := json.Unmarshal(data, &bf); err != nil {
 		return err
 	}
@@ -59,9 +147,9 @@ func (b *BatchFile) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// BatchFileMeta contains metadata about a BatchFile. Not all
+// BatchMeta contains metadata about a Batch. Not all
 // of the fields are required.
-type BatchFileMeta struct {
+type BatchMeta struct {
 	TxBuilderVersion        string `json:"txBuilderVersion,omitempty"`
 	Checksum                string `json:"checksum,omitempty"`
 	CreatedFromSafeAddress  string `json:"createdFromSafeAddress"`
@@ -79,6 +167,81 @@ type BatchTransaction struct {
 	InputValues map[string]string `json:"contractInputsValues"`
 }
 
+// Check will check the batch transaction for errors.
+// An error is defined by:
+// - incorrectly encoded calldata
+// - mismatch in number of arguments
+// It does not currently work on structs, will return no error if a "tuple"
+// is used as an argument. Need to find a generic way to work with structs.
+func (bt *BatchTransaction) Check() error {
+	if len(bt.Method.Inputs) != len(bt.InputValues) {
+		return fmt.Errorf("expected %d inputs but got %d", len(bt.Method.Inputs), len(bt.InputValues))
+	}
+
+	if len(bt.Data) > 0 && bt.Method.Name != "fallback" {
+		if len(bt.Data) < 4 {
+			return fmt.Errorf("must have at least 4 bytes of calldata, got %d", len(bt.Data))
+		}
+		sig := bt.Signature()
+		selector := crypto.Keccak256([]byte(sig))[0:4]
+		if !bytes.Equal(bt.Data[0:4], selector) {
+			return fmt.Errorf("data does not match signature")
+		}
+
+		// Check the calldata
+		values := make([]any, len(bt.Method.Inputs))
+		for i, input := range bt.Method.Inputs {
+			value, ok := bt.InputValues[input.Name]
+			if !ok {
+				return fmt.Errorf("missing input %s", input.Name)
+			}
+			// Need to figure out better way to handle tuples in a generic way
+			if input.Type == "tuple" {
+				return nil
+			}
+			arg, err := unstringifyArg(value, input.Type)
+			if err != nil {
+				return err
+			}
+			values[i] = arg
+		}
+
+		calldata, err := bt.Arguments().PackValues(values)
+		if err != nil {
+			return err
+		}
+		if !bytes.Equal(bt.Data[4:], calldata) {
+			return fmt.Errorf("calldata does not match inputs, expected %s, got %s", hexutil.Encode(bt.Data[4:]), hexutil.Encode(calldata))
+		}
+	}
+	return nil
+}
+
+// Signature returns the function signature of the batch transaction.
+func (bt *BatchTransaction) Signature() string {
+	types := make([]string, len(bt.Method.Inputs))
+	for i, input := range bt.Method.Inputs {
+		types[i] = buildFunctionSignature(input)
+	}
+	return fmt.Sprintf("%s(%s)", bt.Method.Name, strings.Join(types, ","))
+}
+
+func (bt *BatchTransaction) Arguments() abi.Arguments {
+	arguments := make(abi.Arguments, len(bt.Method.Inputs))
+	for i, input := range bt.Method.Inputs {
+		serialized, err := json.Marshal(input)
+		if err != nil {
+			panic(err)
+		}
+		var arg abi.Argument
+		if err := json.Unmarshal(serialized, &arg); err != nil {
+			panic(err)
+		}
+		arguments[i] = arg
+	}
+	return arguments
+}
+
 // UnmarshalJSON will unmarshal a BatchTransaction from JSON.
 func (b *BatchTransaction) UnmarshalJSON(data []byte) error {
 	var bt batchTransactionMarshaling
@@ -87,6 +250,9 @@ func (b *BatchTransaction) UnmarshalJSON(data []byte) error {
 	}
 	b.To = common.HexToAddress(bt.To)
 	b.Value = new(big.Int).SetUint64(bt.Value)
+	if bt.Data != nil {
+		b.Data = common.CopyBytes(*bt.Data)
+	}
 	b.Method = bt.Method
 	b.InputValues = bt.InputValues
 	return nil
@@ -101,8 +267,8 @@ func (b *BatchTransaction) MarshalJSON() ([]byte, error) {
 		InputValues: b.InputValues,
 	}
 	if len(b.Data) != 0 {
-		hex := hexutil.Encode(b.Data)
-		batch.Data = &hex
+		data := hexutil.Bytes(b.Data)
+		batch.Data = &data
 	}
 	return json.Marshal(batch)
 }
@@ -111,7 +277,7 @@ func (b *BatchTransaction) MarshalJSON() ([]byte, error) {
 type batchTransactionMarshaling struct {
 	To          string            `json:"to"`
 	Value       uint64            `json:"value,string"`
-	Data        *string           `json:"data"`
+	Data        *hexutil.Bytes    `json:"data"`
 	Method      ContractMethod    `json:"contractMethod"`
 	InputValues map[string]string `json:"contractInputsValues"`
 }

op-chain-ops/safe/batch_file_test.go

-package safe
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestBatchFileJSONPrepareBedrock(t *testing.T) {
-	testBatchFileJSON(t, "testdata/batch-prepare-bedrock.json")
-}
-
-func TestBatchFileJSONL2OO(t *testing.T) {
-	testBatchFileJSON(t, "testdata/l2-output-oracle.json")
-}
-
-func testBatchFileJSON(t *testing.T, path string) {
-	b, err := os.ReadFile(path)
-	require.NoError(t, err)
-	dec := json.NewDecoder(bytes.NewReader(b))
-	decoded := new(BatchFile)
-	require.NoError(t, dec.Decode(decoded))
-	data, err := json.Marshal(decoded)
-	require.NoError(t, err)
-	require.JSONEq(t, string(b), string(data))
-}

op-chain-ops/safe/batch_helpers.go

+package safe
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// stringifyArg converts a Go type to a string that is representable by ABI.
+// To do so, this function must be recursive to handle nested tuples.
+func stringifyArg(argument any) (string, error) {
+	switch arg := argument.(type) {
+	case common.Address:
+		return arg.String(), nil
+	case *common.Address:
+		return arg.String(), nil
+	case *big.Int:
+		return arg.String(), nil
+	case big.Int:
+		return arg.String(), nil
+	case bool:
+		if arg {
+			return "true", nil
+		}
+		return "false", nil
+	case int64:
+		return strconv.FormatInt(arg, 10), nil
+	case int32:
+		return strconv.FormatInt(int64(arg), 10), nil
+	case int16:
+		return strconv.FormatInt(int64(arg), 10), nil
+	case int8:
+		return strconv.FormatInt(int64(arg), 10), nil
+	case int:
+		return strconv.FormatInt(int64(arg), 10), nil
+	case uint64:
+		return strconv.FormatUint(uint64(arg), 10), nil
+	case uint32:
+		return strconv.FormatUint(uint64(arg), 10), nil
+	case uint16:
+		return strconv.FormatUint(uint64(arg), 10), nil
+	case uint8:
+		return strconv.FormatUint(uint64(arg), 10), nil
+	case uint:
+		return strconv.FormatUint(uint64(arg), 10), nil
+	case []byte:
+		return hexutil.Encode(arg), nil
+	case []any:
+		ret := make([]string, len(arg))
+		for i, v := range arg {
+			str, err := stringifyArg(v)
+			if err != nil {
+				return "", err
+			}
+			ret[i] = str
+		}
+		return "[" + strings.Join(ret, ",") + "]", nil
+	default:
+		typ := reflect.TypeOf(argument)
+		if typ.Kind() == reflect.Ptr {
+			typ = typ.Elem()
+		}
+
+		if typ.Kind() == reflect.Struct {
+			v := reflect.ValueOf(argument)
+			numField := v.NumField()
+			ret := make([]string, numField)
+
+			for i := 0; i < numField; i++ {
+				val := v.Field(i).Interface()
+				str, err := stringifyArg(val)
+				if err != nil {
+					return "", err
+				}
+				ret[i] = str
+			}
+
+			return "[" + strings.Join(ret, ",") + "]", nil
+		}
+
+		return "", fmt.Errorf("unknown type as argument: %T", arg)
+	}
+}
+
+// unstringifyArg converts a string to a Go type.
+func unstringifyArg(arg string, typ string) (any, error) {
+	switch typ {
+	case "address":
+		return common.HexToAddress(arg), nil
+	case "bool":
+		return strconv.ParseBool(arg)
+	case "uint8":
+		val, err := strconv.ParseUint(arg, 10, 8)
+		return uint8(val), err
+	case "uint16":
+		val, err := strconv.ParseUint(arg, 10, 16)
+		return uint16(val), err
+	case "uint32":
+		val, err := strconv.ParseUint(arg, 10, 32)
+		return uint32(val), err
+	case "uint64":
+		val, err := strconv.ParseUint(arg, 10, 64)
+		return val, err
+	case "int8":
+		val, err := strconv.ParseInt(arg, 10, 8)
+		return val, err
+	case "int16":
+		val, err := strconv.ParseInt(arg, 10, 16)
+		return val, err
+	case "int32":
+		val, err := strconv.ParseInt(arg, 10, 32)
+		return val, err
+	case "int64":
+		val, err := strconv.ParseInt(arg, 10, 64)
+		return val, err
+	case "uint256", "int256":
+		val, ok := new(big.Int).SetString(arg, 10)
+		if !ok {
+			return nil, fmt.Errorf("failed to parse %s as big.Int", arg)
+		}
+		return val, nil
+	case "string":
+		return arg, nil
+	case "bytes":
+		return hexutil.Decode(arg)
+	default:
+		return nil, fmt.Errorf("unknown type: %s", typ)
+	}
+}
+
+// createContractInput converts an abi.Argument to one or more ContractInputs.
+func createContractInput(input abi.Argument, inputs []ContractInput) ([]ContractInput, error) {
+	inputType, err := stringifyType(input.Type)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: could probably do better than string comparison?
+	internalType := input.Type.String()
+	if inputType == "tuple" {
+		internalType = input.Type.TupleRawName
+	}
+
+	components := make([]ContractInput, 0)
+	for i, elem := range input.Type.TupleElems {
+		e := *elem
+		arg := abi.Argument{
+			Name: input.Type.TupleRawNames[i],
+			Type: e,
+		}
+		component, err := createContractInput(arg, inputs)
+		if err != nil {
+			return nil, err
+		}
+		components = append(components, component...)
+	}
+
+	contractInput := ContractInput{
+		InternalType: internalType,
+		Name:         input.Name,
+		Type:         inputType,
+		Components:   components,
+	}
+
+	inputs = append(inputs, contractInput)
+
+	return inputs, nil
+}
+
+// stringifyType turns an abi.Type into a string
+func stringifyType(t abi.Type) (string, error) {
+	switch t.T {
+	case abi.TupleTy:
+		return "tuple", nil
+	case abi.BoolTy:
+		return t.String(), nil
+	case abi.AddressTy:
+		return t.String(), nil
+	case abi.UintTy:
+		return t.String(), nil
+	case abi.IntTy:
+		return t.String(), nil
+	case abi.StringTy:
+		return t.String(), nil
+	case abi.BytesTy:
+		return t.String(), nil
+	default:
+		return "", fmt.Errorf("unknown type: %d", t.T)
+	}
+}
+
+// buildFunctionSignature builds a function signature from a ContractInput.
+// It is recursive to handle tuples.
+func buildFunctionSignature(input ContractInput) string {
+	if input.Type == "tuple" {
+		types := make([]string, len(input.Components))
+		for i, component := range input.Components {
+			types[i] = buildFunctionSignature(component)
+		}
+		return fmt.Sprintf("(%s)", strings.Join(types, ","))
+	}
+	return input.InternalType
+}

op-chain-ops/safe/batch_test.go

+package safe
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"math/big"
+	"os"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBatchJSONPrepareBedrock(t *testing.T) {
+	testBatchJSON(t, "testdata/batch-prepare-bedrock.json")
+}
+
+func TestBatchJSONL2OO(t *testing.T) {
+	testBatchJSON(t, "testdata/l2-output-oracle.json")
+}
+
+func testBatchJSON(t *testing.T, path string) {
+	b, err := os.ReadFile(path)
+	require.NoError(t, err)
+	dec := json.NewDecoder(bytes.NewReader(b))
+	decoded := new(Batch)
+	require.NoError(t, dec.Decode(decoded))
+	data, err := json.Marshal(decoded)
+	require.NoError(t, err)
+	require.JSONEq(t, string(b), string(data))
+}
+
+// TestBatchAddCallFinalizeWithdrawalTransaction ensures that structs can be serialized correctly.
+func TestBatchAddCallFinalizeWithdrawalTransaction(t *testing.T) {
+	file, err := os.ReadFile("testdata/portal-abi.json")
+	require.NoError(t, err)
+	portalABI, err := abi.JSON(bytes.NewReader(file))
+	require.NoError(t, err)
+
+	sig := "finalizeWithdrawalTransaction"
+	argument := []any{
+		bindings.TypesWithdrawalTransaction{
+			Nonce:    big.NewInt(0),
+			Sender:   common.Address{19: 0x01},
+			Target:   common.Address{19: 0x02},
+			Value:    big.NewInt(1),
+			GasLimit: big.NewInt(2),
+			Data:     []byte{},
+		},
+	}
+
+	batch := new(Batch)
+	to := common.Address{19: 0x01}
+	value := big.NewInt(222)
+
+	require.NoError(t, batch.AddCall(to, value, sig, argument, portalABI))
+	require.NoError(t, batch.Check())
+	require.Equal(t, batch.Transactions[0].Signature(), "finalizeWithdrawalTransaction((uint256,address,address,uint256,uint256,bytes))")
+
+	expected, err := os.ReadFile("testdata/finalize-withdrawal-tx.json")
+	require.NoError(t, err)
+
+	serialized, err := json.Marshal(batch)
+	require.NoError(t, err)
+	require.JSONEq(t, string(expected), string(serialized))
+}
+
+// TestBatchAddCallDespostTransaction ensures that simple calls can be serialized correctly.
+func TestBatchAddCallDespositTransaction(t *testing.T) {
+	file, err := os.ReadFile("testdata/portal-abi.json")
+	require.NoError(t, err)
+	portalABI, err := abi.JSON(bytes.NewReader(file))
+	require.NoError(t, err)
+
+	batch := new(Batch)
+	to := common.Address{19: 0x01}
+	value := big.NewInt(222)
+	sig := "depositTransaction"
+	argument := []any{
+		common.Address{01},
+		big.NewInt(2),
+		uint64(100),
+		false,
+		[]byte{},
+	}
+
+	require.NoError(t, batch.AddCall(to, value, sig, argument, portalABI))
+	require.NoError(t, batch.Check())
+	require.Equal(t, batch.Transactions[0].Signature(), "depositTransaction(address,uint256,uint64,bool,bytes)")
+
+	expected, err := os.ReadFile("testdata/deposit-tx.json")
+	require.NoError(t, err)
+
+	serialized, err := json.Marshal(batch)
+	require.NoError(t, err)
+	require.JSONEq(t, string(expected), string(serialized))
+}
+
+// TestBatchCheck checks for the various failure cases of Batch.Check
+// as well as a simple check for a valid batch.
+func TestBatchCheck(t *testing.T) {
+	cases := []struct {
+		name string
+		bt   BatchTransaction
+		err  error
+	}{
+		{
+			name: "bad-input-count",
+			bt: BatchTransaction{
+				Method: ContractMethod{},
+				InputValues: map[string]string{
+					"foo": "bar",
+				},
+			},
+			err: errors.New("expected 0 inputs but got 1"),
+		},
+		{
+			name: "bad-calldata-too-small",
+			bt: BatchTransaction{
+				Data: []byte{0x01},
+			},
+			err: errors.New("must have at least 4 bytes of calldata, got 1"),
+		},
+		{
+			name: "bad-calldata-mismatch",
+			bt: BatchTransaction{
+				Data: []byte{0x01, 0x02, 0x03, 0x04},
+				Method: ContractMethod{
+					Name: "foo",
+				},
+			},
+			err: errors.New("data does not match signature"),
+		},
+		{
+			name: "good-calldata",
+			bt: BatchTransaction{
+				Data: []byte{0xc2, 0x98, 0x55, 0x78},
+				Method: ContractMethod{
+					Name: "foo",
+				},
+			},
+			err: nil,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			require.Equal(t, tc.err, tc.bt.Check())
+		})
+	}
+}

op-chain-ops/safe/testdata/deposit-tx.json

+{
+   "version": "",
+   "chainId": "",
+   "createdAt": 0,
+   "meta": {
+     "createdFromSafeAddress": "",
+     "createdFromOwnerAddress": "",
+     "name": "",
+     "description": ""
+   },
+   "transactions": [
+     {
+       "to": "0x0000000000000000000000000000000000000001",
+       "value": "222",
+       "data": "0xe9e05c42000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000",
+       "contractMethod": {
+         "inputs": [
+           {
+             "internalType": "address",
+             "name": "_to",
+             "type": "address"
+           },
+           {
+             "internalType": "uint256",
+             "name": "_value",
+             "type": "uint256"
+           },
+           {
+             "internalType": "uint64",
+             "name": "_gasLimit",
+             "type": "uint64"
+           },
+           {
+             "internalType": "bool",
+             "name": "_isCreation",
+             "type": "bool"
+           },
+           {
+             "internalType": "bytes",
+             "name": "_data",
+             "type": "bytes"
+           }
+         ],
+         "name": "depositTransaction",
+         "payable": false
+       },
+       "contractInputsValues": {
+         "_data": "0x",
+         "_gasLimit": "100",
+         "_isCreation": "false",
+         "_to": "0x0100000000000000000000000000000000000000",
+         "_value": "2"
+       }
+     }
+   ]
+ }

op-chain-ops/safe/testdata/finalize-withdrawal-tx.json

+{
+  "version": "",
+  "chainId": "",
+  "createdAt": 0,
+  "meta": {
+    "createdFromSafeAddress": "",
+    "createdFromOwnerAddress": "",
+    "name": "",
+    "description": ""
+  },
+  "transactions": [
+    {
+      "to": "0x0000000000000000000000000000000000000001",
+      "value": "222",
+      "data": "0x8c3152e900000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000000",
+      "contractMethod": {
+        "inputs": [
+          {
+            "internalType": "TypesWithdrawalTransaction",
+            "name": "_tx",
+            "type": "tuple",
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "nonce",
+                "type": "uint256"
+              },
+              {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+              },
+              {
+                "internalType": "address",
+                "name": "target",
+                "type": "address"
+              },
+              {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint256",
+                "name": "gasLimit",
+                "type": "uint256"
+              },
+              {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+              }
+            ]
+          }
+        ],
+        "name": "finalizeWithdrawalTransaction",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "_tx": "[0,0x0000000000000000000000000000000000000001,0x0000000000000000000000000000000000000002,1,2,0x]"
+      }
+    }
+  ]
+}

op-chain-ops/safe/testdata/portal-abi.json

+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "version",
+        "type": "uint8"
+      }
+    ],
+    "name": "Initialized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      }
+    ],
+    "name": "Paused",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "version",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "opaqueData",
+        "type": "bytes"
+      }
+    ],
+    "name": "TransactionDeposited",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      }
+    ],
+    "name": "Unpaused",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "withdrawalHash",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "bool",
+        "name": "success",
+        "type": "bool"
+      }
+    ],
+    "name": "WithdrawalFinalized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "withdrawalHash",
+        "type": "bytes32"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      }
+    ],
+    "name": "WithdrawalProven",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "GUARDIAN",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "L2_ORACLE",
+    "outputs": [
+      {
+        "internalType": "contract L2OutputOracle",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "SYSTEM_CONFIG",
+    "outputs": [
+      {
+        "internalType": "contract SystemConfig",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_value",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint64",
+        "name": "_gasLimit",
+        "type": "uint64"
+      },
+      {
+        "internalType": "bool",
+        "name": "_isCreation",
+        "type": "bool"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_data",
+        "type": "bytes"
+      }
+    ],
+    "name": "depositTransaction",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "donateETH",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "nonce",
+            "type": "uint256"
+          },
+          {
+            "internalType": "address",
+            "name": "sender",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "target",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "value",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "gasLimit",
+            "type": "uint256"
+          },
+          {
+            "internalType": "bytes",
+            "name": "data",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct Types.WithdrawalTransaction",
+        "name": "_tx",
+        "type": "tuple"
+      }
+    ],
+    "name": "finalizeWithdrawalTransaction",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "name": "finalizedWithdrawals",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "guardian",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract L2OutputOracle",
+        "name": "_l2Oracle",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_guardian",
+        "type": "address"
+      },
+      {
+        "internalType": "contract SystemConfig",
+        "name": "_systemConfig",
+        "type": "address"
+      },
+      {
+        "internalType": "bool",
+        "name": "_paused",
+        "type": "bool"
+      }
+    ],
+    "name": "initialize",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_l2OutputIndex",
+        "type": "uint256"
+      }
+    ],
+    "name": "isOutputFinalized",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "l2Oracle",
+    "outputs": [
+      {
+        "internalType": "contract L2OutputOracle",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "l2Sender",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint64",
+        "name": "_byteCount",
+        "type": "uint64"
+      }
+    ],
+    "name": "minimumGasLimit",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "params",
+    "outputs": [
+      {
+        "internalType": "uint128",
+        "name": "prevBaseFee",
+        "type": "uint128"
+      },
+      {
+        "internalType": "uint64",
+        "name": "prevBoughtGas",
+        "type": "uint64"
+      },
+      {
+        "internalType": "uint64",
+        "name": "prevBlockNum",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "pause",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "paused",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "nonce",
+            "type": "uint256"
+          },
+          {
+            "internalType": "address",
+            "name": "sender",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "target",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "value",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "gasLimit",
+            "type": "uint256"
+          },
+          {
+            "internalType": "bytes",
+            "name": "data",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct Types.WithdrawalTransaction",
+        "name": "_tx",
+        "type": "tuple"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_l2OutputIndex",
+        "type": "uint256"
+      },
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "version",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "stateRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "messagePasserStorageRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "latestBlockhash",
+            "type": "bytes32"
+          }
+        ],
+        "internalType": "struct Types.OutputRootProof",
+        "name": "_outputRootProof",
+        "type": "tuple"
+      },
+      {
+        "internalType": "bytes[]",
+        "name": "_withdrawalProof",
+        "type": "bytes[]"
+      }
+    ],
+    "name": "proveWithdrawalTransaction",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "name": "provenWithdrawals",
+    "outputs": [
+      {
+        "internalType": "bytes32",
+        "name": "outputRoot",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "uint128",
+        "name": "timestamp",
+        "type": "uint128"
+      },
+      {
+        "internalType": "uint128",
+        "name": "l2OutputIndex",
+        "type": "uint128"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "systemConfig",
+    "outputs": [
+      {
+        "internalType": "contract SystemConfig",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "unpause",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "version",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "stateMutability": "payable",
+    "type": "receive"
+  }
+]

op-challenger/fault/disk.go

 package fault
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/hashicorp/go-multierror"
 	"golang.org/x/exp/slices"
 )
 
@@ -31,7 +31,7 @@ func (d *diskManager) RemoveAllExcept(keep []common.Address) error {
 	if err != nil {
 		return fmt.Errorf("failed to list directory: %w", err)
 	}
-	var result error
+	var errs []error
 	for _, entry := range entries {
 		if !entry.IsDir() || !strings.HasPrefix(entry.Name(), gameDirPrefix) {
 			// Skip files and directories that don't have the game directory prefix.
@@ -49,9 +49,7 @@ func (d *diskManager) RemoveAllExcept(keep []common.Address) error {
 			// Preserve data for games we should keep.
 			continue
 		}
-		if err := os.RemoveAll(filepath.Join(d.datadir, entry.Name())); err != nil {
-			result = multierror.Append(result, err)
-		}
+		errs = append(errs, os.RemoveAll(filepath.Join(d.datadir, entry.Name())))
 	}
-	return result
+	return errors.Join(errs...)
 }

op-challenger/fault/monitor.go

@@ -87,11 +87,7 @@ func (m *gameMonitor) minGameTimestamp() uint64 {
 	return 0
 }
 
-func (m *gameMonitor) progressGames(ctx context.Context) error {
-	blockNum, err := m.fetchBlockNumber(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to load current block number: %w", err)
-	}
+func (m *gameMonitor) progressGames(ctx context.Context, blockNum uint64) error {
 	games, err := m.source.FetchAllGamesAtBlock(ctx, m.minGameTimestamp(), new(big.Int).SetUint64(blockNum))
 	if err != nil {
 		return fmt.Errorf("failed to load games: %w", err)
@@ -147,13 +143,26 @@ func (m *gameMonitor) fetchOrCreateGamePlayer(gameData FaultDisputeGame) (gamePl
 func (m *gameMonitor) MonitorGames(ctx context.Context) error {
 	m.logger.Info("Monitoring fault dispute games")
 
+	blockNum := uint64(0)
 	for {
-		err := m.progressGames(ctx)
-		if err != nil {
-			m.logger.Error("Failed to progress games", "err", err)
-		}
-		if err := m.clock.SleepCtx(ctx, 300*time.Millisecond); err != nil {
-			return err
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			nextBlockNum, err := m.fetchBlockNumber(ctx)
+			if err != nil {
+				m.logger.Error("Failed to load current block number", "err", err)
+				continue
+			}
+			if nextBlockNum > blockNum {
+				blockNum = nextBlockNum
+				if err := m.progressGames(ctx, nextBlockNum); err != nil {
+					m.logger.Error("Failed to progress games", "err", err)
+				}
+			}
+			if err := m.clock.SleepCtx(ctx, time.Second); err != nil {
+				return err
+			}
 		}
 	}
 }

op-challenger/fault/monitor_test.go

@@ -65,8 +65,7 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 		},
 	}
 
-	err := monitor.progressGames(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(1)))
 
 	require.Len(t, games.created, 2, "should create game agents")
 	require.Contains(t, games.created, addr1)
@@ -75,7 +74,7 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 	require.Equal(t, 1, games.created[addr2].progressCount)
 
 	// The stub will fail the test if a game is created with the same address multiple times
-	require.NoError(t, monitor.progressGames(context.Background()), "should only create games once")
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(2)), "should only create games once")
 	require.Equal(t, 2, games.created[addr1].progressCount)
 	require.Equal(t, 2, games.created[addr2].progressCount)
 }
@@ -96,8 +95,7 @@ func TestMonitorOnlyCreateSpecifiedGame(t *testing.T) {
 		},
 	}
 
-	err := monitor.progressGames(context.Background())
-	require.NoError(t, err)
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(1)))
 
 	require.Len(t, games.created, 1, "should only create allowed game")
 	require.Contains(t, games.created, addr2)
@@ -122,14 +120,14 @@ func TestDeletePlayersWhenNoLongerInListOfGames(t *testing.T) {
 	}
 	source.games = allGames
 
-	require.NoError(t, monitor.progressGames(context.Background()))
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(1)))
 	require.Len(t, games.created, 2)
 	require.Contains(t, games.created, addr1)
 	require.Contains(t, games.created, addr2)
 
 	// First game is now old enough it's not returned in the list of active games
 	source.games = source.games[1:]
-	require.NoError(t, monitor.progressGames(context.Background()))
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(2)))
 	require.Len(t, games.created, 2)
 	require.Contains(t, games.created, addr1)
 	require.Contains(t, games.created, addr2)
@@ -139,7 +137,7 @@ func TestDeletePlayersWhenNoLongerInListOfGames(t *testing.T) {
 
 	// First game now reappears (inexplicably but usefully for our testing)
 	source.games = allGames
-	require.NoError(t, monitor.progressGames(context.Background()))
+	require.NoError(t, monitor.progressGames(context.Background(), uint64(3)))
 	// A new player is created for it because the original was deleted
 	require.Len(t, games.created, 2)
 	require.Contains(t, games.created, addr1)
@@ -165,7 +163,7 @@ func TestCleanupResourcesOfCompletedGames(t *testing.T) {
 		},
 	}
 
-	err := monitor.progressGames(context.Background())
+	err := monitor.progressGames(context.Background(), uint64(1))
 	require.NoError(t, err)
 
 	require.Len(t, games.created, 2, "should create game agents")
@@ -187,8 +185,10 @@ func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor
 		t:       t,
 		created: make(map[common.Address]*stubGame),
 	}
+	i := uint64(1)
 	fetchBlockNum := func(ctx context.Context) (uint64, error) {
-		return 1234, nil
+		i++
+		return i, nil
 	}
 	disk := &stubDiskManager{
 		gameDirExists: make(map[common.Address]bool),

op-e2e/e2eutils/challenger/helper.go

@@ -5,6 +5,7 @@ import (
 	"crypto/ecdsa"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -13,6 +14,7 @@ import (
 	op_challenger "github.com/ethereum-optimism/optimism/op-challenger"
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
@@ -24,6 +26,7 @@ import (
 
 type Helper struct {
 	log     log.Logger
+	t       *testing.T
 	require *require.Assertions
 	dir     string
 	cancel  func()
@@ -108,6 +111,7 @@ func NewChallenger(t *testing.T, ctx context.Context, l1Endpoint string, name st
 	}()
 	return &Helper{
 		log:     log,
+		t:       t,
 		require: require.New(t),
 		dir:     cfg.Datadir,
 		cancel:  cancel,
@@ -171,11 +175,27 @@ func (h *Helper) VerifyGameDataExists(games ...GameAddr) {
 	}
 }
 
-func (h *Helper) VerifyNoGameDataExists(games ...GameAddr) {
-	for _, game := range games {
-		addr := game.Addr()
-		h.require.NoDirExistsf(h.gameDataDir(addr), "should have data for game %v", addr)
-	}
+func (h *Helper) WaitForGameDataDeletion(ctx context.Context, games ...GameAddr) {
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	err := wait.For(ctx, time.Second, func() (bool, error) {
+		for _, game := range games {
+			addr := game.Addr()
+			dir := h.gameDataDir(addr)
+			_, err := os.Stat(dir)
+			if errors.Is(err, os.ErrNotExist) {
+				// This game has been successfully deleted
+				continue
+			}
+			if err != nil {
+				return false, fmt.Errorf("failed to check dir %v is deleted: %w", dir, err)
+			}
+			h.t.Errorf("Game data directory %v not yet deleted", dir)
+			return false, nil
+		}
+		return true, nil
+	})
+	h.require.NoErrorf(err, "should have deleted game data directories")
 }
 
 func (h *Helper) gameDataDir(addr common.Address) string {

op-e2e/faultproof_test.go

@@ -102,7 +102,7 @@ func TestMultipleCannonGames(t *testing.T) {
 	game2.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
 
 	// Check that the game directories are removed
-	challenger.VerifyNoGameDataExists(game1, game2)
+	challenger.WaitForGameDataDeletion(ctx, game1, game2)
 }
 
 func TestResolveDisputeGame(t *testing.T) {

packages/contracts-bedrock/deploy-config/getting-started.json

 {
-  "numDeployConfirmations": 1,
-
   "finalSystemOwner": "ADMIN",
   "portalGuardian": "ADMIN",
 
@@ -9,6 +7,7 @@
   "l1ChainID": 5,
   "l2ChainID": 42069,
   "l2BlockTime": 2,
+  "l1BlockTime": 12,
 
   "maxSequencerDrift": 600,
   "sequencerWindowSize": 3600,

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import { Script } from "forge-std/Script.sol";
-import { Test } from "forge-std/Test.sol";
+
 import { console2 as console } from "forge-std/console2.sol";
 import { stdJson } from "forge-std/StdJson.sol";
 

pnpm-lock.yaml

@@ -17,7 +17,7 @@ importers:
     devDependencies:
       '@babel/eslint-parser':
         specifier: ^7.18.2
-        version: 7.18.2(@babel/core@7.22.10)(eslint@8.47.0)
+        version: 7.22.10(@babel/core@7.22.10)(eslint@8.47.0)
       '@changesets/changelog-github':
         specifier: ^0.4.8
         version: 0.4.8
@@ -83,7 +83,7 @@ importers:
         version: 5.2.0(eslint@8.47.0)
       eslint-plugin-react:
         specifier: ^7.24.0
-        version: 7.24.0(eslint@8.47.0)
+        version: 7.33.2(eslint@8.47.0)
       eslint-plugin-unicorn:
         specifier: ^42.0.0
         version: 42.0.0(eslint@8.47.0)
@@ -662,18 +662,18 @@ packages:
       - supports-color
     dev: true
 
-  /@babel/eslint-parser@7.18.2(@babel/core@7.22.10)(eslint@8.47.0):
-    resolution: {integrity: sha512-oFQYkE8SuH14+uR51JVAmdqwKYXGRjEXx7s+WiagVjqQ+HPE+nnwyF2qlVG8evUsUHmPcA+6YXMEDbIhEyQc5A==}
+  /@babel/eslint-parser@7.22.10(@babel/core@7.22.10)(eslint@8.47.0):
+    resolution: {integrity: sha512-0J8DNPRXQRLeR9rPaUMM3fA+RbixjnVLe/MRMYCkp3hzgsSuxCHQ8NN8xQG1wIHKJ4a1DTROTvFJdW+B5/eOsg==}
     engines: {node: ^10.13.0 || ^12.13.0 || >=14.0.0}
     peerDependencies:
-      '@babel/core': '>=7.11.0'
+      '@babel/core': ^7.11.0
       eslint: ^7.5.0 || ^8.0.0
     dependencies:
       '@babel/core': 7.22.10
+      '@nicolo-ribaudo/eslint-scope-5-internals': 5.1.1-v1
       eslint: 8.47.0
-      eslint-scope: 5.1.1
       eslint-visitor-keys: 2.1.0
-      semver: 6.3.0
+      semver: 6.3.1
     dev: true
 
   /@babel/generator@7.22.10:
@@ -2670,6 +2670,12 @@ packages:
       '@motionone/dom': 10.16.2
       tslib: 2.6.0
 
+  /@nicolo-ribaudo/eslint-scope-5-internals@5.1.1-v1:
+    resolution: {integrity: sha512-54/JRvkLIzzDWshCWfuhadfrfZVPiElY8Fcgmg1HroEly/EDSszzhBAsarCux+D/kOslTRquNzuyGSmUSTTHGg==}
+    dependencies:
+      eslint-scope: 5.1.1
+    dev: true
+
   /@noble/curves@1.0.0:
     resolution: {integrity: sha512-2upgEu0iLiDVDZkNLeFV2+ht0BAVgQnEmCk6JsOch9Rp8xfkMCbvbAZlA2pBHQc73dbl+vFOXfqkf4uemdn0bw==}
     dependencies:
@@ -5712,24 +5718,13 @@ packages:
     resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
     dev: true
 
-  /array-includes@3.1.5:
-    resolution: {integrity: sha512-iSDYZMMyTPkiFasVqfuAQnWAYcvO/SeBSCGKePoEthjp4LEMTe4uLc7b025o4jAZpHhihh8xPo99TNWUWWkGDQ==}
-    engines: {node: '>= 0.4'}
-    dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.0
-      es-abstract: 1.21.2
-      get-intrinsic: 1.2.1
-      is-string: 1.0.7
-    dev: true
-
   /array-includes@3.1.6:
     resolution: {integrity: sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==}
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       get-intrinsic: 1.2.1
       is-string: 1.0.7
     dev: true
@@ -5749,7 +5744,7 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
       get-intrinsic: 1.2.1
     dev: true
@@ -5760,29 +5755,40 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
 
-  /array.prototype.flatmap@1.2.4:
-    resolution: {integrity: sha512-r9Z0zYoxqHz60vvQbWEdXIEtCwHF0yxaWfno9qzXeNHvfyl3BZqygmGzb84dsubyaXLH4husF+NFgMSdpZhk2Q==}
+  /array.prototype.flatmap@1.3.1:
+    resolution: {integrity: sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==}
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
-      function-bind: 1.1.1
+      es-abstract: 1.22.1
+      es-shim-unscopables: 1.0.0
     dev: true
 
-  /array.prototype.flatmap@1.3.1:
-    resolution: {integrity: sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==}
-    engines: {node: '>= 0.4'}
+  /array.prototype.tosorted@1.1.1:
+    resolution: {integrity: sha512-pZYPXPRl2PqWcsUs6LOMn+1f1532nEoPTYowBtqLwAW+W8vSVhkIGnmOX1t/UQjD6YGI0vcD2B1U7ZFGQH9jnQ==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
+      get-intrinsic: 1.2.1
     dev: true
 
+  /arraybuffer.prototype.slice@1.0.1:
+    resolution: {integrity: sha512-09x0ZWFEjj4WD8PDbykUwo3t9arLn8NIzmmYEJFpYekOAQjpkGSyrQhNoRTcwwcFRu+ycWF78QZ63oWTqSjBcw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      array-buffer-byte-length: 1.0.0
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+      get-intrinsic: 1.2.1
+      is-array-buffer: 3.0.2
+      is-shared-array-buffer: 1.0.2
+
   /arrify@1.0.1:
     resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==}
     engines: {node: '>=0.10.0'}
@@ -5828,6 +5834,12 @@ packages:
     resolution: {integrity: sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==}
     dev: true
 
+  /asynciterator.prototype@1.0.0:
+    resolution: {integrity: sha512-wwHYEIS0Q80f5mosx3L/dfG5t5rjEa9Ft51GTaNt862EnpyGHpgz2RkZvLPp1oF5TnAiTohkEKVEu8pQPJI7Vg==}
+    dependencies:
+      has-symbols: 1.0.3
+    dev: true
+
   /asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
@@ -7567,11 +7579,12 @@ packages:
     dependencies:
       is-arrayish: 0.2.1
 
-  /es-abstract@1.21.2:
-    resolution: {integrity: sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==}
+  /es-abstract@1.22.1:
+    resolution: {integrity: sha512-ioRRcXMO6OFyRpyzV3kE1IIBd4WG5/kltnzdxSCqoP8CMGs/Li+M1uF5o7lOkZVFjDs+NLesthnF66Pg/0q0Lw==}
     engines: {node: '>= 0.4'}
     dependencies:
       array-buffer-byte-length: 1.0.0
+      arraybuffer.prototype.slice: 1.0.1
       available-typed-arrays: 1.0.5
       call-bind: 1.0.2
       es-set-tostringtag: 2.0.1
@@ -7598,10 +7611,14 @@ packages:
       object-keys: 1.1.1
       object.assign: 4.1.4
       regexp.prototype.flags: 1.5.0
+      safe-array-concat: 1.0.0
       safe-regex-test: 1.0.0
       string.prototype.trim: 1.2.7
       string.prototype.trimend: 1.0.6
       string.prototype.trimstart: 1.0.6
+      typed-array-buffer: 1.0.0
+      typed-array-byte-length: 1.0.0
+      typed-array-byte-offset: 1.0.0
       typed-array-length: 1.0.4
       unbox-primitive: 1.0.2
       which-typed-array: 1.1.11
@@ -7620,6 +7637,25 @@ packages:
       stop-iteration-iterator: 1.0.0
     dev: false
 
+  /es-iterator-helpers@1.0.13:
+    resolution: {integrity: sha512-LK3VGwzvaPWobO8xzXXGRUOGw8Dcjyfk62CsY/wfHN75CwsJPbuypOYJxK6g5RyEL8YDjIWcl6jgd8foO6mmrA==}
+    dependencies:
+      asynciterator.prototype: 1.0.0
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+      es-abstract: 1.22.1
+      es-set-tostringtag: 2.0.1
+      function-bind: 1.1.1
+      get-intrinsic: 1.2.1
+      globalthis: 1.0.3
+      has-property-descriptors: 1.0.0
+      has-proto: 1.0.1
+      has-symbols: 1.0.3
+      internal-slot: 1.0.5
+      iterator.prototype: 1.1.0
+      safe-array-concat: 1.0.0
+    dev: true
+
   /es-set-tostringtag@2.0.1:
     resolution: {integrity: sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==}
     engines: {node: '>= 0.4'}
@@ -8117,25 +8153,29 @@ packages:
       eslint: 8.47.0
     dev: true
 
-  /eslint-plugin-react@7.24.0(eslint@8.47.0):
-    resolution: {integrity: sha512-KJJIx2SYx7PBx3ONe/mEeMz4YE0Lcr7feJTCMyyKb/341NcjuAgim3Acgan89GfPv7nxXK2+0slu0CWXYM4x+Q==}
+  /eslint-plugin-react@7.33.2(eslint@8.47.0):
+    resolution: {integrity: sha512-73QQMKALArI8/7xGLNI/3LylrEYrlKZSb5C9+q3OtOewTnMQi5cT+aE9E41sLCmli3I9PGGmD1yiZydyo4FEPw==}
     engines: {node: '>=4'}
     peerDependencies:
-      eslint: ^3 || ^4 || ^5 || ^6 || ^7
+      eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8
     dependencies:
-      array-includes: 3.1.5
-      array.prototype.flatmap: 1.2.4
+      array-includes: 3.1.6
+      array.prototype.flatmap: 1.3.1
+      array.prototype.tosorted: 1.1.1
       doctrine: 2.1.0
+      es-iterator-helpers: 1.0.13
       eslint: 8.47.0
-      has: 1.0.3
+      estraverse: 5.3.0
       jsx-ast-utils: 3.2.0
       minimatch: 3.1.2
-      object.entries: 1.1.4
-      object.fromentries: 2.0.4
-      object.values: 1.1.5
-      prop-types: 15.7.2
-      resolve: 2.0.0-next.3
-      string.prototype.matchall: 4.0.5
+      object.entries: 1.1.6
+      object.fromentries: 2.0.6
+      object.hasown: 1.1.2
+      object.values: 1.1.6
+      prop-types: 15.8.1
+      resolve: 2.0.0-next.4
+      semver: 6.3.1
+      string.prototype.matchall: 4.0.8
     dev: true
 
   /eslint-plugin-unicorn@42.0.0(eslint@8.47.0):
@@ -9078,7 +9118,7 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       functions-have-names: 1.2.3
 
   /functional-red-black-tree@1.0.1:
@@ -9956,6 +9996,13 @@ packages:
   /is-arrayish@0.2.1:
     resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
 
+  /is-async-function@2.0.0:
+    resolution: {integrity: sha512-Y1JXKrfykRJGdlDwdKlLpLyMIiWqWvuSd17TvZk68PLAOGOoF4Xyav1z0Xhoi+gCYjZVeC5SI+hYFOfvXmGRCA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-tostringtag: 1.0.0
+    dev: true
+
   /is-bigint@1.0.4:
     resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==}
     dependencies:
@@ -10028,6 +10075,12 @@ packages:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
 
+  /is-finalizationregistry@1.0.2:
+    resolution: {integrity: sha512-0by5vtUJs8iFQb5TYUHHPudOR+qXYIMKtiUzvLIZITZUjknFmziyBJuLhVRc+Ds0dREFlskDNJKYIdIzu/9pfw==}
+    dependencies:
+      call-bind: 1.0.2
+    dev: true
+
   /is-fullwidth-code-point@1.0.0:
     resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==}
     engines: {node: '>=0.10.0'}
@@ -10080,7 +10133,6 @@ packages:
 
   /is-map@2.0.2:
     resolution: {integrity: sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==}
-    dev: false
 
   /is-my-ip-valid@1.0.1:
     resolution: {integrity: sha512-jxc8cBcOWbNK2i2aTkCZP6i7wkHF1bqKFrwEHuN5Jtg5BSaZHUZQ/JTOJwoV41YvHnOaRyWWh72T/KvfNz9DJg==}
@@ -10158,7 +10210,6 @@ packages:
 
   /is-set@2.0.2:
     resolution: {integrity: sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==}
-    dev: false
 
   /is-shared-array-buffer@1.0.2:
     resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==}
@@ -10246,7 +10297,6 @@ packages:
 
   /is-weakmap@2.0.1:
     resolution: {integrity: sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==}
-    dev: false
 
   /is-weakref@1.0.2:
     resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==}
@@ -10258,7 +10308,6 @@ packages:
     dependencies:
       call-bind: 1.0.2
       get-intrinsic: 1.2.1
-    dev: false
 
   /is-windows@1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
@@ -10281,7 +10330,6 @@ packages:
 
   /isarray@2.0.5:
     resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
-    dev: false
 
   /isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
@@ -10436,6 +10484,16 @@ packages:
       istanbul-lib-report: 3.0.1
     dev: true
 
+  /iterator.prototype@1.1.0:
+    resolution: {integrity: sha512-rjuhAk1AJ1fssphHD0IFV6TWL40CwRZ53FrztKx43yk2v6rguBYsY4Bj1VU4HmoMmKwZUlx7mfnhDf9cOp4YTw==}
+    dependencies:
+      define-properties: 1.2.0
+      get-intrinsic: 1.2.1
+      has-symbols: 1.0.3
+      has-tostringtag: 1.0.0
+      reflect.getprototypeof: 1.0.3
+    dev: true
+
   /jackspeak@2.2.1:
     resolution: {integrity: sha512-MXbxovZ/Pm42f6cDIDkl3xpwv1AGwObKwfmjs2nQePiy85tP3fatofl3FC1aBsOtP/6fq5SbtgHwWcMsLP+bDw==}
     engines: {node: '>=14'}
@@ -12562,23 +12620,13 @@ packages:
       has-symbols: 1.0.3
       object-keys: 1.1.1
 
-  /object.entries@1.1.4:
-    resolution: {integrity: sha512-h4LWKWE+wKQGhtMjZEBud7uLGhqyLwj8fpHOarZhD2uY3C9cRtk57VQ89ke3moByLXMedqs3XCHzyb4AmA2DjA==}
-    engines: {node: '>= 0.4'}
-    dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.0
-      es-abstract: 1.21.2
-    dev: true
-
-  /object.fromentries@2.0.4:
-    resolution: {integrity: sha512-EsFBshs5RUUpQEY1D4q/m59kMfz4YJvxuNCJcv/jWwOJr34EaVnG11ZrZa0UHB3wnzV1wx8m58T4hQL8IuNXlQ==}
+  /object.entries@1.1.6:
+    resolution: {integrity: sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==}
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
-      has: 1.0.3
+      es-abstract: 1.22.1
     dev: true
 
   /object.fromentries@2.0.6:
@@ -12587,7 +12635,7 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /object.groupby@1.0.0:
@@ -12595,17 +12643,15 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       get-intrinsic: 1.2.1
     dev: true
 
-  /object.values@1.1.5:
-    resolution: {integrity: sha512-QUZRW0ilQ3PnPpbNtgdNV1PDbEqLIiSFB3l+EnGtBQ/8SUTLj1PZwtQHABZtLgwpJZTSZhuGLOGk57Drx2IvYg==}
-    engines: {node: '>= 0.4'}
+  /object.hasown@1.1.2:
+    resolution: {integrity: sha512-B5UIT3J1W+WuWIU55h0mjlwaqxiE5vYENJXIXZ4VFe05pNYrkKuK0U/6aFcb0pKywYJh7IhfoqUfKVmrJJHZHw==}
     dependencies:
-      call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /object.values@1.1.6:
@@ -12614,7 +12660,7 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /obliterator@1.6.1:
@@ -13412,8 +13458,8 @@ packages:
       read: 2.1.0
     dev: true
 
-  /prop-types@15.7.2:
-    resolution: {integrity: sha512-8QQikdH7//R2vurIJSutZ1smHYTcLpRWEOlHnzcWHmBYrOGUysKwSsrC89BCiFj3CbrfJ/nXFdJepOVrY1GCHQ==}
+  /prop-types@15.8.1:
+    resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
     dependencies:
       loose-envify: 1.4.0
       object-assign: 4.1.1
@@ -13791,6 +13837,18 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /reflect.getprototypeof@1.0.3:
+    resolution: {integrity: sha512-TTAOZpkJ2YLxl7mVHWrNo3iDMEkYlva/kgFcXndqMgbo/AZUmmavEkdXV+hXtE4P8xdyEKRzalaFqZVuwIk/Nw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+      es-abstract: 1.22.1
+      get-intrinsic: 1.2.1
+      globalthis: 1.0.3
+      which-builtin-type: 1.1.3
+    dev: true
+
   /regenerator-runtime@0.13.11:
     resolution: {integrity: sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==}
 
@@ -13984,11 +14042,13 @@ packages:
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
-  /resolve@2.0.0-next.3:
-    resolution: {integrity: sha512-W8LucSynKUIDu9ylraa7ueVZ7hc0uAgJBxVsQSKOXOyle8a93qXhcz+XAXZ8bIq2d6i4Ehddn6Evt+0/UwKk6Q==}
+  /resolve@2.0.0-next.4:
+    resolution: {integrity: sha512-iMDbmAWtfU+MHpxt/I5iWI7cY6YVEZUQ3MBgPQ++XD1PELuJHIl82xBmObyP2KyQmkNB2dsqF7seoQQiAn5yDQ==}
+    hasBin: true
     dependencies:
       is-core-module: 2.13.0
       path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
     dev: true
 
   /restore-cursor@3.1.0:
@@ -14127,6 +14187,15 @@ packages:
       tslib: 2.6.0
     dev: true
 
+  /safe-array-concat@1.0.0:
+    resolution: {integrity: sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==}
+    engines: {node: '>=0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.2.1
+      has-symbols: 1.0.3
+      isarray: 2.0.5
+
   /safe-buffer@5.1.2:
     resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
 
@@ -14720,12 +14789,12 @@ packages:
       strip-ansi: 7.1.0
     dev: true
 
-  /string.prototype.matchall@4.0.5:
-    resolution: {integrity: sha512-Z5ZaXO0svs0M2xd/6By3qpeKpLKd9mO4v4q3oMEQrk8Ck4xOD5d5XeBOOjGrmVZZ/AHB1S0CgG4N5r1G9N3E2Q==}
+  /string.prototype.matchall@4.0.8:
+    resolution: {integrity: sha512-6zOCOcJ+RJAQshcTvXPHoxoQGONa3e/Lqx90wUA+wEzX78sg5Bo+1tQo4N0pohS0erG9qtCqJDjNCQBjeWVxyg==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       get-intrinsic: 1.2.1
       has-symbols: 1.0.3
       internal-slot: 1.0.5
@@ -14739,21 +14808,21 @@ packages:
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string.prototype.trimend@1.0.6:
     resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string.prototype.trimstart@1.0.6:
     resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string_decoder@0.10.31:
     resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
@@ -15552,6 +15621,33 @@ packages:
       - supports-color
     dev: true
 
+  /typed-array-buffer@1.0.0:
+    resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.2.1
+      is-typed-array: 1.1.12
+
+  /typed-array-byte-length@1.0.0:
+    resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      for-each: 0.3.3
+      has-proto: 1.0.1
+      is-typed-array: 1.1.12
+
+  /typed-array-byte-offset@1.0.0:
+    resolution: {integrity: sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.5
+      call-bind: 1.0.2
+      for-each: 0.3.3
+      has-proto: 1.0.1
+      is-typed-array: 1.1.12
+
   /typed-array-length@1.0.4:
     resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==}
     dependencies:
@@ -16743,6 +16839,24 @@ packages:
       is-string: 1.0.7
       is-symbol: 1.0.4
 
+  /which-builtin-type@1.1.3:
+    resolution: {integrity: sha512-YmjsSMDBYsM1CaFiayOVT06+KJeXf0o5M/CAd4o1lTadFAtacTUM49zoYxr/oroopFDfhvN6iEcBxUyc3gvKmw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      function.prototype.name: 1.1.5
+      has-tostringtag: 1.0.0
+      is-async-function: 2.0.0
+      is-date-object: 1.0.5
+      is-finalizationregistry: 1.0.2
+      is-generator-function: 1.0.10
+      is-regex: 1.1.4
+      is-weakref: 1.0.2
+      isarray: 2.0.5
+      which-boxed-primitive: 1.0.2
+      which-collection: 1.0.1
+      which-typed-array: 1.1.11
+    dev: true
+
   /which-collection@1.0.1:
     resolution: {integrity: sha512-W8xeTUwaln8i3K/cY1nGXzdnVZlidBcagyNFtBdD5kxnb4TvGKR7FfSIS3mYpwWS1QUCutfKz8IY8RjftB0+1A==}
     dependencies:
@@ -16750,7 +16864,6 @@ packages:
       is-set: 2.0.2
       is-weakmap: 2.0.1
       is-weakset: 2.0.2
-    dev: false
 
   /which-module@1.0.0:
     resolution: {integrity: sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==}