[never merge] Execution test v1.9.2

cannon/cmd/preimage.go

@@ -0,0 +1,70 @@
+package cmd
+
+import (
+	"database/sql"
+	"encoding/binary"
+	"github.com/ethereum-optimism/optimism/op-program/client"
+	"github.com/ethereum/go-ethereum/common"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type MemoryPreimageOracle struct {
+	data map[common.Hash][]byte
+}
+
+func NewMemoryPreimageOracle(path string) (*MemoryPreimageOracle, error) {
+	db, err := sql.Open("sqlite3", path)
+	if err != nil {
+		panic(err)
+	}
+
+	rows, err := db.Query("SELECT key, value FROM kv_store")
+	if err != nil {
+		panic(err)
+	}
+	data := map[common.Hash][]byte{}
+	count := 0
+	for rows.Next() {
+		count++
+		if count%10000 == 0 {
+			println("current loaded", count)
+		}
+		var key []byte
+		var value []byte
+		if err = rows.Scan(&key, &value); err != nil {
+			panic(err)
+		}
+		data[common.BytesToHash(key)] = value
+	}
+	return &MemoryPreimageOracle{
+		data: data,
+	}, nil
+}
+
+func (p *MemoryPreimageOracle) Hint(v []byte) {
+}
+
+func (p *MemoryPreimageOracle) GetPreimage(k [32]byte) []byte {
+	switch k {
+	case client.L1HeadLocalIndex.PreimageKey():
+		return common.FromHex("0x93ba31bf89e54237af6e6564e69d328b2b5202adf643de4cb097431f74f4a6c1")
+	case client.L2OutputRootLocalIndex.PreimageKey():
+		return common.FromHex("0x056a42a72c62b0e80658cfc6ff0e87419cb38771d16a69c9399a58a28046e281")
+	case client.L2ClaimLocalIndex.PreimageKey():
+		return common.FromHex("0x0615473db962c6ccf828d01f5fe3f12b167588047435b4ff433660f5aa64875b")
+	case client.L2ClaimBlockNumberLocalIndex.PreimageKey():
+		return binary.BigEndian.AppendUint64(nil, 15378258)
+	case client.L2ChainIDLocalIndex.PreimageKey():
+		opSepoliaChainId := uint64(11155420)
+		return binary.BigEndian.AppendUint64(nil, opSepoliaChainId)
+	}
+	return p.data[common.BytesToHash(k[:])]
+}
+
+func (p *MemoryPreimageOracle) Start() error {
+	return nil
+}
+
+func (p *MemoryPreimageOracle) Close() error {
+	return nil
+}

cannon/cmd/run.go

@@ -94,7 +94,7 @@ var (
 	RunInfoAtFlag = &cli.GenericFlag{
 		Name:     "info-at",
 		Usage:    "step pattern to print info at: " + patternHelp,
-		Value:    MustStepMatcherFlag("%100000"),
+		Value:    MustStepMatcherFlag("%100000000"),
 		Required: false,
 	}
 	RunPProfCPU = &cli.BoolFlag{
@@ -339,9 +339,10 @@ func Run(ctx *cli.Context) error {
 		args = []string{""}
 	}
 
-	poOut := Logger(os.Stdout, log.LevelInfo).With("module", "host")
-	poErr := Logger(os.Stderr, log.LevelInfo).With("module", "host")
-	po, err := NewProcessPreimageOracle(args[0], args[1:], poOut, poErr)
+	//poOut := Logger(os.Stdout, log.LevelInfo).With("module", "host")
+	//poErr := Logger(os.Stderr, log.LevelInfo).With("module", "host")
+	// po, err := NewProcessPreimageOracle(args[0], args[1:], poOut, poErr)
+	po, err := NewMemoryPreimageOracle("temp/compat/sepolia-fjord/kvstore.db") //NewProcessPreimageOracle(args[0], args[1:], poOut, poErr)
 	if err != nil {
 		return fmt.Errorf("failed to create pre-image oracle process: %w", err)
 	}
@@ -413,9 +414,9 @@ func Run(ctx *cli.Context) error {
 	snapshotFmt := ctx.String(RunSnapshotFmtFlag.Name)
 
 	stepFn := vm.Step
-	if po.cmd != nil {
-		stepFn = Guard(po.cmd.ProcessState, stepFn)
-	}
+	//	if po.cmd != nil {
+	//		stepFn = Guard(po.cmd.ProcessState, stepFn)
+	//	}
 
 	start := time.Now()
 

go.mod

@@ -31,6 +31,7 @@ require (
 	github.com/libp2p/go-libp2p-pubsub v0.12.0
 	github.com/libp2p/go-libp2p-testing v0.12.0
 	github.com/mattn/go-isatty v0.0.20
+	github.com/mattn/go-sqlite3 v1.14.24
 	github.com/minio/minio-go/v7 v7.0.76
 	github.com/multiformats/go-base32 v0.1.0
 	github.com/multiformats/go-multiaddr v0.13.0

go.sum

@@ -477,6 +477,8 @@ github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
 github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
 github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=

op-program/Dockerfile.repro

@@ -35,7 +35,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build cd op-program && make op-pro
     GOOS=linux GOARCH=mips GOMIPS=softfloat GITCOMMIT=$GIT_COMMIT GITDATE=$GIT_DATE VERSION="$OP_PROGRAM_VERSION"
 
 # Run the op-program-client.elf binary directly through cannon's load-elf subcommand.
-RUN /app/cannon/bin/cannon load-elf --path /app/op-program/bin/op-program-client.elf --out /app/op-program/bin/prestate.json --meta ""
+RUN /app/cannon/bin/cannon load-elf --path /app/op-program/bin/op-program-client.elf --out /app/op-program/bin/prestate.json -meta /app/op-program/bin/meta.json
 
 # Generate the prestate proof containing the absolute pre-state hash.
 RUN /app/cannon/bin/cannon run --proof-at '=0' --stop-at '=1' --input /app/op-program/bin/prestate.json --meta "" --proof-fmt '/app/op-program/bin/%d.json' --output ""
@@ -48,4 +48,5 @@ FROM scratch AS export-stage
 COPY --from=builder /app/op-program/bin/op-program .
 COPY --from=builder /app/op-program/bin/op-program-client.elf .
 COPY --from=builder /app/op-program/bin/prestate.json .
+COPY --from=builder /app/op-program/bin/meta.json .
 COPY --from=builder /app/op-program/bin/prestate-proof.json .

op-program/Makefile

@@ -21,7 +21,8 @@ op-program: \
 	op-program-client-mips
 
 op-program-host:
-	env GO111MODULE=on GOOS=$(TARGETOS) GOARCH=$(TARGETARCH) CGO_ENABLED=0 go build -v -ldflags "$(LDFLAGSSTRING)" -o ./bin/op-program ./host/cmd/main.go
+  # CGO is required to use sqlite3
+	env GO111MODULE=on GOOS=$(TARGETOS) GOARCH=$(TARGETARCH) CGO_ENABLED=1 go build -v -ldflags "$(LDFLAGSSTRING)" -o ./bin/op-program ./host/cmd/main.go
 
 op-program-client:
 	env GO111MODULE=on GOOS=$(TARGETOS) GOARCH=$(TARGETARCH) go build -v -ldflags "$(PC_LDFLAGSSTRING)" -o ./bin/op-program-client ./client/cmd/main.go

op-program/client/cmd/local.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"os"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-program/client"
+	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+)
+
+func main() {
+	// Default to a machine parsable but relatively human friendly log format.
+	// Don't do anything fancy to detect if color output is supported.
+	logger := oplog.NewLogger(os.Stdout, oplog.CLIConfig{
+		Level:  log.LevelInfo,
+		Format: oplog.FormatLogFmt,
+		Color:  false,
+	})
+	oplog.SetGlobalLogHandler(logger.Handler())
+	client.Local(logger, "temp/compat/sepolia-fjord/kvstore.db")
+}

op-program/client/preimage.go

@@ -0,0 +1,64 @@
+package client
+
+import (
+	"database/sql"
+	"encoding/binary"
+	preimage "github.com/ethereum-optimism/optimism/op-preimage"
+	"github.com/ethereum/go-ethereum/common"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type MemoryPreimageOracle struct {
+	data map[common.Hash][]byte
+}
+
+func NewMemoryPreimageOracle(path string) (*MemoryPreimageOracle, error) {
+	db, err := sql.Open("sqlite3", path)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := db.Query("SELECT key, value FROM kv_store")
+	if err != nil {
+		return nil, err
+	}
+	data := map[common.Hash][]byte{}
+	count := 0
+	for rows.Next() {
+		count++
+		if count%10000 == 0 {
+			println("current loaded", count)
+		}
+		var key []byte
+		var value []byte
+		if err = rows.Scan(&key, &value); err != nil {
+			return nil, err
+		}
+		data[common.BytesToHash(key)] = value
+	}
+	return &MemoryPreimageOracle{
+		data: data,
+	}, nil
+}
+
+func (p *MemoryPreimageOracle) Hint(v preimage.Hint) {
+
+}
+
+func (p *MemoryPreimageOracle) Get(k preimage.Key) []byte {
+	switch k.PreimageKey() {
+	case L1HeadLocalIndex.PreimageKey():
+		return common.FromHex("0x93ba31bf89e54237af6e6564e69d328b2b5202adf643de4cb097431f74f4a6c1")
+	case L2OutputRootLocalIndex.PreimageKey():
+		return common.FromHex("0x056a42a72c62b0e80658cfc6ff0e87419cb38771d16a69c9399a58a28046e281")
+	case L2ClaimLocalIndex.PreimageKey():
+		return common.FromHex("0x0615473db962c6ccf828d01f5fe3f12b167588047435b4ff433660f5aa64875b")
+	case L2ClaimBlockNumberLocalIndex.PreimageKey():
+		return binary.BigEndian.AppendUint64(nil, 15378356)
+	case L2ChainIDLocalIndex.PreimageKey():
+		opSepoliaChainId := uint64(11155420)
+		return binary.BigEndian.AppendUint64(nil, opSepoliaChainId)
+	}
+	key := k.PreimageKey()
+	return p.data[common.BytesToHash(key[:])]
+}

op-program/client/program.go

@@ -75,3 +75,40 @@ func runDerivation(logger log.Logger, cfg *rollup.Config, l2Cfg *params.ChainCon
 	}
 	return claim.ValidateClaim(logger, l2ClaimBlockNum, eth.Bytes32(l2Claim), l2Source)
 }
+
+func Local(logger log.Logger, path string) {
+	log.Info("Starting fault proof program client for local ")
+	if err := runProgramLocal(logger, path); errors.Is(err, claim.ErrClaimNotValid) {
+		log.Error("Claim is invalid", "err", err)
+		os.Exit(1)
+	} else if err != nil {
+		log.Error("Program failed", "err", err)
+		os.Exit(2)
+	} else {
+		log.Info("Claim successfully verified")
+		os.Exit(0)
+	}
+}
+
+func runProgramLocal(logger log.Logger, path string) error {
+	pClient, err := NewMemoryPreimageOracle(path) //preimage.NewOracleClient(preimageOracle)
+	if err != nil {
+		return err
+	}
+	l1PreimageOracle := l1.NewCachingOracle(l1.NewPreimageOracle(pClient, pClient))
+	l2PreimageOracle := l2.NewCachingOracle(l2.NewPreimageOracle(pClient, pClient))
+
+	bootInfo := NewBootstrapClient(pClient).BootInfo()
+	logger.Info("Program Bootstrapped", "bootInfo", bootInfo)
+	return runDerivation(
+		logger,
+		bootInfo.RollupConfig,
+		bootInfo.L2ChainConfig,
+		bootInfo.L1Head,
+		bootInfo.L2OutputRoot,
+		bootInfo.L2Claim,
+		bootInfo.L2ClaimBlockNumber,
+		l1PreimageOracle,
+		l2PreimageOracle,
+	)
+}