initial PoDA integration

1) batch inbox to verify blobs in array
2) send to inbox during batch submission
3) verify blobs during derivation (WIP)

Author: jagdeep sidhu

op-batcher/batch_submitter.go

@@ -42,6 +42,8 @@ const (
 	// defaultDialTimeout is default duration the service will wait on
 	// startup to make a connection to either the L1 or L2 backends.
 	defaultDialTimeout = 5 * time.Second
+	// SYSCOIN
+	appendSequencerBatchMethodName = "appendSequencerBatch()"
 )
 
 // Main is the entrypoint into the Batch Submitter. This method returns a
@@ -206,6 +208,16 @@ func NewBatchSubmitter(cfg Config, l log.Logger) (*BatchSubmitter, error) {
 		return nil, err
 	}
 
+	// SYSCOIN
+	syscoinClient, err := dialSyscoinClientWithTimeout(ctx, cfg.SyscoinRpc)
+	if err != nil {
+		return nil, err
+	}
+	podaClient, err := dialPoDAClientWithTimeout(ctx, cfg.PoDARpc)
+	if err != nil {
+		return nil, err
+	}
+
 	chainID, err := l1Client.ChainID(ctx)
 	if err != nil {
 		return nil, err
@@ -217,7 +229,6 @@ func NewBatchSubmitter(cfg Config, l log.Logger) (*BatchSubmitter, error) {
 	}
 
 	log.Info("starting batch submitter", "submitter_addr", addr, "submitter_bal", sequencerBalance)
-
 	txManagerConfig := txmgr.Config{
 		Log:                       l,
 		Name:                      "Batch Submitter",
@@ -233,6 +244,8 @@ func NewBatchSubmitter(cfg Config, l log.Logger) (*BatchSubmitter, error) {
 		L1Client:          l1Client,
 		L2Client:          l2Client,
 		RollupNode:        rollupClient,
+		SyscoinNode:       syscoinClient,
+		PoDANode:          podaClient,
 		MinL1TxSize:       cfg.MinL1TxSize,
 		MaxL1TxSize:       cfg.MaxL1TxSize,
 		BatchInboxAddress: batchInboxAddress,
@@ -243,7 +256,6 @@ func NewBatchSubmitter(cfg Config, l log.Logger) (*BatchSubmitter, error) {
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
-
 	return &BatchSubmitter{
 		cfg:   batcherCfg,
 		addr:  addr,
@@ -338,6 +350,7 @@ mainLoop:
 				continue
 			}
 			// Hand role do-while loop to fully pull all frames out of the channel
+			VHs := make([]common.Hash, 0)
 			for {
 				// Collect the output frame
 				data := new(bytes.Buffer)
@@ -350,52 +363,74 @@ mainLoop:
 					l.log.Error("error outputting frame", "err", err)
 					continue mainLoop
 				}
-
-				// Query for the submitter's current nonce.
-				walletAddr := crypto.PubkeyToAddress(l.cfg.PrivKey.PublicKey)
-				ctx, cancel = context.WithTimeout(l.ctx, time.Second*10)
-				nonce, err := l.cfg.L1Client.NonceAt(ctx, walletAddr, nil)
-				cancel()
+				// post data.Bytes() into SYS RPC to get version hash
+				vh, err := l.cfg.SyscoinNode.CreatePoDA(ctx, data.Bytes())
 				if err != nil {
-					l.log.Error("unable to get current nonce", "err", err)
+					l.log.Error("unable to create PoDA tx", "err", err)
 					continue mainLoop
 				}
-
-				// Create the transaction
-				ctx, cancel = context.WithTimeout(l.ctx, time.Second*10)
-				tx, err := l.CraftTx(ctx, data.Bytes(), nonce)
-				cancel()
+				VHs = append(VHs, vh)
+				// If `ch.OutputFrame` returned io.EOF we don't need to submit any more frames for this channel.
+				if done {
+					break // local do-while loop
+				}
+			}
+			vhBytes := make([]byte, 0)
+			for _, vh := range VHs {
+				// wait for VH to confirm (MTP > 0)
+				podaCreateStatus, err := l.cfg.SyscoinNode.IsPoDAConfirmed(ctx, vh)
 				if err != nil {
-					l.log.Error("unable to craft tx", "err", err)
+					l.log.Error("unable to check for PoDA confirmation", "err", err)
 					continue mainLoop
 				}
-
-				// Construct the a closure that will update the txn with the current gas prices.
-				updateGasPrice := func(ctx context.Context) (*types.Transaction, error) {
-					l.log.Debug("updating batch tx gas price")
-					return l.UpdateGasPrice(ctx, tx)
-				}
-
-				// Wait until one of our submitted transactions confirms. If no
-				// receipt is received it's likely our gas price was too low.
-				// TODO: does the tx manager nicely replace the tx?
-				//  (submit a new one, that's within the channel timeout, but higher fee than previously submitted tx? Or use a cheap cancel tx?)
-				ctx, cancel = context.WithTimeout(l.ctx, time.Second*time.Duration(l.cfg.ChannelTimeout))
-				receipt, err := l.txMgr.Send(ctx, updateGasPrice, l.cfg.L1Client.SendTransaction)
-				cancel()
-				if err != nil {
-					l.log.Warn("unable to publish tx", "err", err)
+				if podaCreateStatus == false {
+					l.log.Error("PoDA not confirmed", "err", err)
 					continue mainLoop
 				}
+				vhBytes = append(vhBytes, vh.Bytes()...)
+			}
+			// Query for the submitter's current nonce.
+			walletAddr := crypto.PubkeyToAddress(l.cfg.PrivKey.PublicKey)
+			ctx, cancel = context.WithTimeout(l.ctx, time.Second*10)
+			nonce, err := l.cfg.L1Client.NonceAt(ctx, walletAddr, nil)
+			cancel()
+			if err != nil {
+				l.log.Error("unable to get current nonce", "err", err)
+				continue mainLoop
+			}
+			// Create the transaction
+			ctx, cancel = context.WithTimeout(l.ctx, time.Second*10)
+			// call the appendSequencerBatch in the batch inbox contract, append the function sig infront of array of VH 32 byte array
+			sig := crypto.Keccak256([]byte(appendSequencerBatchMethodName))[:4]
+			calldata := append(sig, vhBytes...)
+			tx, err := l.CraftTx(ctx, calldata, nonce)
+			cancel()
+			if err != nil {
+				l.log.Error("unable to craft tx", "err", err)
+				continue mainLoop
+			}
 
-				// The transaction was successfully submitted.
-				l.log.Info("tx successfully published", "tx_hash", receipt.TxHash, "channel_id", l.ch.ID())
+			// Construct the a closure that will update the txn with the current gas prices.
+			updateGasPrice := func(ctx context.Context) (*types.Transaction, error) {
+				l.log.Debug("updating batch tx gas price")
+				return l.UpdateGasPrice(ctx, tx, uint64(len(VHs))*1800)
+			}
 
-				// If `ch.OutputFrame` returned io.EOF we don't need to submit any more frames for this channel.
-				if done {
-					break // local do-while loop
-				}
+			// Wait until one of our submitted transactions confirms. If no
+			// receipt is received it's likely our gas price was too low.
+			// TODO: does the tx manager nicely replace the tx?
+			//  (submit a new one, that's within the channel timeout, but higher fee than previously submitted tx? Or use a cheap cancel tx?)
+			ctx, cancel = context.WithTimeout(l.ctx, time.Second*time.Duration(l.cfg.ChannelTimeout))
+			receipt, err := l.txMgr.Send(ctx, updateGasPrice, l.cfg.L1Client.SendTransaction)
+			cancel()
+			if err != nil {
+				l.log.Warn("unable to publish tx", "err", err)
+				continue mainLoop
 			}
+
+			// The transaction was successfully submitted.
+			l.log.Info("tx successfully published", "tx_hash", receipt.TxHash, "channel_id", l.ch.ID())
+
 			// TODO: if we exit to the mainLoop early on an error,
 			// it would be nice if we can determine which blocks are still readable from the partially submitted data.
 			// We can open a channel-in-reader, parse the data up to which we managed to submit it,
@@ -423,7 +458,6 @@ func (l *BatchSubmitter) CraftTx(ctx context.Context, data []byte, nonce uint64)
 	}
 
 	gasFeeCap := txmgr.CalcGasFeeCap(head.BaseFee, gasTipCap)
-
 	rawTx := &types.DynamicFeeTx{
 		ChainID:   l.cfg.ChainID,
 		Nonce:     nonce,
@@ -447,7 +481,7 @@ func (l *BatchSubmitter) CraftTx(ctx context.Context, data []byte, nonce uint64)
 // updated gas prices sampled from the existing network conditions.
 //
 // NOTE: Thie method SHOULD NOT publish the resulting transaction.
-func (l *BatchSubmitter) UpdateGasPrice(ctx context.Context, tx *types.Transaction) (*types.Transaction, error) {
+func (l *BatchSubmitter) UpdateGasPrice(ctx context.Context, tx *types.Transaction, additionalGas uint64) (*types.Transaction, error) {
 	gasTipCap, err := l.cfg.L1Client.SuggestGasTipCap(ctx)
 	if err != nil {
 		return nil, err
@@ -466,7 +500,7 @@ func (l *BatchSubmitter) UpdateGasPrice(ctx context.Context, tx *types.Transacti
 		To:        tx.To(),
 		GasTipCap: gasTipCap,
 		GasFeeCap: gasFeeCap,
-		Gas:       tx.Gas(),
+		Gas:       tx.Gas() + additionalGas,
 		Data:      tx.Data(),
 	}
 
@@ -506,6 +540,33 @@ func dialRollupClientWithTimeout(ctx context.Context, url string) (*sources.Roll
 	return sources.NewRollupClient(client.NewBaseRPCClient(rpcCl)), nil
 }
 
+// SYSCOIN
+// dialRollupClientWithTimeout attempts to dial the RPC provider using the provided
+// URL. If the dial doesn't complete within defaultDialTimeout seconds, this
+// method will return an error.
+func dialSyscoinClientWithTimeout(ctx context.Context, url string) (*sources.SyscoinClient, error) {
+	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
+	defer cancel()
+
+	rpcCl, err := rpc.DialContext(ctxt, url)
+	if err != nil {
+		return nil, err
+	}
+
+	return sources.NewSyscoinClient(client.NewBaseRPCClient(rpcCl)), nil
+}
+func dialPoDAClientWithTimeout(ctx context.Context, url string) (*sources.PoDAClient, error) {
+	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
+	defer cancel()
+
+	rpcCl, err := rpc.DialContext(ctxt, url)
+	if err != nil {
+		return nil, err
+	}
+
+	return sources.NewPoDAClient(client.NewBaseRPCClient(rpcCl)), nil
+}
+
 // parseAddress parses an ETH address from a hex string. This method will fail if
 // the address is not a valid hexadecimal address.
 func parseAddress(address string) (common.Address, error) {

op-batcher/config.go

@@ -24,6 +24,12 @@ type Config struct {
 	// RollupRpc is the HTTP provider URL for the L2 rollup node.
 	RollupRpc string
 
+	// SYSCOIN SyscoinRpc is the HTTP provider URL for the L1 Syscoin UTXO node.
+	SyscoinRpc string
+
+	// PoDARpc is the HTTP provider URL for the public PoDA archiving service.
+	PoDARpc string
+
 	// MinL1TxSize is the minimum size of a batch tx submitted to L1.
 	MinL1TxSize uint64
 
@@ -101,6 +107,9 @@ func NewConfig(ctx *cli.Context) Config {
 		L1EthRpc:                   ctx.GlobalString(flags.L1EthRpcFlag.Name),
 		L2EthRpc:                   ctx.GlobalString(flags.L2EthRpcFlag.Name),
 		RollupRpc:                  ctx.GlobalString(flags.RollupRpcFlag.Name),
+		// SYSCOIN
+		SyscoinRpc:                 ctx.GlobalString(flags.SyscoinRpcFlag.Name),
+		PoDARpc:                 	ctx.GlobalString(flags.PoDARpcFlag.Name),
 		MinL1TxSize:                ctx.GlobalUint64(flags.MinL1TxSizeBytesFlag.Name),
 		MaxL1TxSize:                ctx.GlobalUint64(flags.MaxL1TxSizeBytesFlag.Name),
 		ChannelTimeout:             ctx.GlobalUint64(flags.ChannelTimeoutFlag.Name),

op-batcher/flags/flags.go

@@ -33,6 +33,19 @@ var (
 		Required: true,
 		EnvVar:   opservice.PrefixEnvVar(envVarPrefix, "ROLLUP_RPC"),
 	}
+	// SYSCOIN
+	SyscoinRpcFlag = cli.StringFlag{
+		Name:     "syscoin-rpc",
+		Usage:    "HTTP provider URL for Syscoin node",
+		Required: true,
+		EnvVar:   opservice.PrefixEnvVar(envVarPrefix, "SYSCOIN_RPC"),
+	}
+	PoDARpcFlag = cli.StringFlag{
+		Name:     "poda-rpc",
+		Usage:    "HTTP provider URL for PoDA node",
+		Required: true,
+		EnvVar:   opservice.PrefixEnvVar(envVarPrefix, "PODA_RPC"),
+	}
 	MinL1TxSizeBytesFlag = cli.Uint64Flag{
 		Name:     "min-l1-tx-size-bytes",
 		Usage:    "The minimum size of a batch tx submitted to L1.",
@@ -109,6 +122,9 @@ var requiredFlags = []cli.Flag{
 	L1EthRpcFlag,
 	L2EthRpcFlag,
 	RollupRpcFlag,
+	// SYSCOIN
+	SyscoinRpcFlag,
+	PoDARpcFlag,
 	MinL1TxSizeBytesFlag,
 	MaxL1TxSizeBytesFlag,
 	ChannelTimeoutFlag,

op-batcher/sequencer/driver.go

@@ -23,6 +23,9 @@ type Config struct {
 	L2Client *ethclient.Client
 
 	RollupNode *sources.RollupClient
+	// SYSCOIN
+	SyscoinNode *sources.SyscoinClient
+	PoDANode *sources.PoDAClient
 
 	// Limit the size of txs
 	MinL1TxSize uint64

op-node/cmd/genesis/cmd.go

@@ -65,8 +65,8 @@ var Subcommands = cli.Commands{
 			if err != nil {
 				return err
 			}
-
-			rollupConfig := makeRollupConfig(config, l1StartBlock, l2Genesis, predeploys.DevOptimismPortalAddr, predeploys.DevL2OutputOracleAddr)
+			// SYSCOIN
+			rollupConfig := makeRollupConfig(config, l1StartBlock, l2Genesis, predeploys.DevOptimismPortalAddr, predeploys.DevL2OutputOracleAddr, config.BatchInboxAddress)
 
 			if err := writeGenesisFile(ctx.String("outfile.l1"), l1Genesis); err != nil {
 				return err
@@ -154,6 +154,10 @@ var Subcommands = cli.Commands{
 			if err != nil {
 				return err
 			}
+			batchInboxAddr, err := hh.GetDeployment("BatchInbox")
+			if err != nil {
+				return err
+			}
 			l2Addrs := &genesis.L2Addresses{
 				ProxyAdmin:                  proxyAdmin.Address,
 				L1StandardBridgeProxy:       l1SBP.Address,
@@ -164,7 +168,7 @@ var Subcommands = cli.Commands{
 				return err
 			}
 
-			rollupConfig := makeRollupConfig(config, l1StartBlock, l2Genesis, portalProxy.Address, outputOracle.Address)
+			rollupConfig := makeRollupConfig(config, l1StartBlock, l2Genesis, portalProxy.Address, outputOracle.Address, batchInboxAddr.Address)
 
 			if err := writeGenesisFile(ctx.String("outfile.l2"), l2Genesis); err != nil {
 				return err
@@ -180,6 +184,7 @@ func makeRollupConfig(
 	l2Genesis *core.Genesis,
 	portalAddr common.Address,
 	outputOracleAddr common.Address,
+	batchInboxAddr common.Address,
 ) *rollup.Config {
 	return &rollup.Config{
 		Genesis: rollup.Genesis{
@@ -201,7 +206,7 @@ func makeRollupConfig(
 		L2ChainID:              new(big.Int).SetUint64(config.L2ChainID),
 		P2PSequencerAddress:    config.P2PSequencerAddress,
 		FeeRecipientAddress:    config.OptimismL2FeeRecipient,
-		BatchInboxAddress:      config.BatchInboxAddress,
+		BatchInboxAddress:      batchInboxAddr,
 		BatchSenderAddress:     config.BatchSenderAddress,
 		DepositContractAddress: portalAddr,
 		L2OutputOracleAddress:  outputOracleAddr,