Feat/split oracletx

challenger/README.md

@@ -18,8 +18,13 @@ To configure the Challenger, fill in the values in the `~/.opinit/challenger.jso
   // Version is the version used to build output root.
   // Please refer to `spec_version.json` for the correct version for each network.
   "version": 1,
-  // ListenAddress is the address to listen for incoming requests.
-  "listen_address": "localhost:3001",
+  // Server is the configuration for the server.
+  "server": {
+    "address":      "localhost:3000",
+    "allow_origins": "*",
+    "allow_headers": "Origin, Content-Type, Accept",
+    "allow_methods": "GET",
+  },
   "l1_node": {
     "chain_id": "testnet-l1-1",
     "bech32_prefix": "init",

challenger/child/child.go

@@ -57,7 +57,7 @@ func NewChildV1(
 }
 
 func (ch *Child) Initialize(ctx context.Context, processedHeight int64, startOutputIndex uint64, host hostNode, bridgeInfo ophosttypes.QueryBridgeResponse, challenger challenger) (time.Time, error) {
-	_, err := ch.BaseChild.Initialize(ctx, processedHeight, startOutputIndex, bridgeInfo, nil)
+	_, err := ch.BaseChild.Initialize(ctx, processedHeight, startOutputIndex, bridgeInfo, nil, nil)
 	if err != nil {
 		return time.Time{}, err
 	}

executor/README.md

@@ -16,8 +16,13 @@ To configure the Executor, fill in the values in the `~/.opinit/executor.json` f
   // Version is the version used to build output root.
   // Please refer to `spec_version.json` for the correct version for each network.
   "version": 1,
-  // ListenAddress is the address to listen for incoming requests.
-  "listen_address": "localhost:3000",
+  // Server is the configuration for the server.
+  "server": {
+    "address":      "localhost:3000",
+    "allow_origins": "*",
+    "allow_headers": "Origin, Content-Type, Accept",
+    "allow_methods": "GET",
+  },
   "l1_node": {
     "chain_id": "testnet-l1-1",
     "bech32_prefix": "init",
@@ -47,6 +52,11 @@ To configure the Executor, fill in the values in the `~/.opinit/executor.json` f
   //
   // If you don't want to use the bridge executor feature, you can leave it empty.
   "bridge_executor": "",
+  // OracleBridgeExecutor is the key name in the keyring for the oracle bridge executor,
+  // which is used to relay oracle transaction from l1 to l2.
+  //
+  // If L2 is using oracle, you need to set this field.
+  "oracle_bridge_executor": "",
 
   // DisableOutputSubmitter is the flag to disable the output submitter.
   // If it is true, the output submitter will not be started.

executor/batch/handler.go

@@ -201,11 +201,12 @@ func (bs *BatchSubmitter) finalizeBatch(ctx context.Context, blockHeight int64)
 		checksums,
 	)
 
-	msg, err := bs.da.CreateBatchMsg(headerData)
+	msg, sender, err := bs.da.CreateBatchMsg(headerData)
 	if err != nil {
 		return err
 	} else if msg != nil {
 		bs.processedMsgs = append(bs.processedMsgs, btypes.ProcessedMsgs{
+			Sender:    sender,
 			Msgs:      []sdk.Msg{msg},
 			Timestamp: time.Now().UnixNano(),
 			Save:      true,
@@ -220,11 +221,12 @@ func (bs *BatchSubmitter) finalizeBatch(ctx context.Context, blockHeight int64)
 			types.MustInt64ToUint64(int64(len(checksums))),
 			chunk,
 		)
-		msg, err := bs.da.CreateBatchMsg(chunkData)
+		msg, sender, err := bs.da.CreateBatchMsg(chunkData)
 		if err != nil {
 			return err
 		} else if msg != nil {
 			bs.processedMsgs = append(bs.processedMsgs, btypes.ProcessedMsgs{
+				Sender:    sender,
 				Msgs:      []sdk.Msg{msg},
 				Timestamp: time.Now().UnixNano(),
 				Save:      true,

executor/batch/noop_da.go

@@ -20,10 +20,10 @@ func NewNoopDA() *NoopDA {
 	return &NoopDA{}
 }
 
-func (n NoopDA) Start(_ context.Context)                  {}
-func (n NoopDA) HasKey() bool                             { return false }
-func (n NoopDA) CreateBatchMsg(_ []byte) (sdk.Msg, error) { return nil, nil }
-func (n NoopDA) BroadcastMsgs(nil btypes.ProcessedMsgs)   {}
+func (n NoopDA) Start(_ context.Context)                          {}
+func (n NoopDA) HasKey() bool                                     { return false }
+func (n NoopDA) CreateBatchMsg(_ []byte) (sdk.Msg, string, error) { return nil, "", nil }
+func (n NoopDA) BroadcastMsgs(nil btypes.ProcessedMsgs)           {}
 func (n NoopDA) ProcessedMsgsToRawKV(_ []btypes.ProcessedMsgs, _ bool) ([]types.RawKV, error) {
 	return nil, nil
 }

executor/celestia/celestia.go

@@ -7,14 +7,10 @@ import (
 
 	"go.uber.org/zap"
 
-	"github.com/cometbft/cometbft/crypto/merkle"
-
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/codec"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 
-	inclusion "github.com/celestiaorg/go-square/v2/inclusion"
 	sh "github.com/celestiaorg/go-square/v2/share"
 
 	executortypes "github.com/initia-labs/opinit-bots/executor/types"
@@ -45,9 +41,6 @@ type Celestia struct {
 	cfg    nodetypes.NodeConfig
 	db     types.DB
 	logger *zap.Logger
-
-	processedMsgs []btypes.ProcessedMsgs
-	msgQueue      []sdk.Msg
 }
 
 func NewDACelestia(
@@ -60,21 +53,13 @@ func NewDACelestia(
 		cfg:    cfg,
 		db:     db,
 		logger: logger,
-
-		processedMsgs: make([]btypes.ProcessedMsgs, 0),
-		msgQueue:      make([]sdk.Msg, 0),
 	}
 
 	appCodec, txConfig, err := createCodec(cfg.Bech32Prefix)
 	if err != nil {
 		panic(err)
 	}
 
-	if cfg.BroadcasterConfig != nil {
-		cfg.BroadcasterConfig.BuildTxWithMessages = c.BuildTxWithMessages
-		cfg.BroadcasterConfig.PendingTxToProcessedMsgs = c.PendingTxToProcessedMsgs
-	}
-
 	node, err := node.NewNode(cfg, db, logger, appCodec, txConfig)
 	if err != nil {
 		panic(err)
@@ -95,7 +80,7 @@ func createCodec(bech32Prefix string) (codec.Codec, client.TxConfig, error) {
 }
 
 func (c *Celestia) Initialize(ctx context.Context, batch batchNode, bridgeId uint64, keyringConfig *btypes.KeyringConfig) error {
-	err := c.node.Initialize(ctx, 0, keyringConfig)
+	err := c.node.Initialize(ctx, 0, c.keyringConfigs(keyringConfig))
 	if err != nil {
 		return err
 	}
@@ -142,66 +127,32 @@ func (c Celestia) GetHeight() int64 {
 	return c.node.GetHeight()
 }
 
-func (c Celestia) CreateBatchMsg(rawBlob []byte) (sdk.Msg, error) {
-	submitter, err := c.GetAddressStr()
-	if err != nil {
-		if errors.Is(err, types.ErrKeyNotSet) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	blob, err := sh.NewV0Blob(c.namespace, rawBlob)
-	if err != nil {
-		return nil, err
-	}
-	commitment, err := inclusion.CreateCommitment(blob,
-		merkle.HashFromByteSlices,
-		// https://github.com/celestiaorg/celestia-app/blob/4f4d0f7ff1a43b62b232726e52d1793616423df7/pkg/appconsts/v1/app_consts.go#L6
-		64,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	dataLength, err := types.SafeIntToUint32(len(blob.Data()))
-	if err != nil {
-		return nil, err
-	}
-
-	return &celestiatypes.MsgPayForBlobsWithBlob{
-		MsgPayForBlobs: &celestiatypes.MsgPayForBlobs{
-			Signer:           submitter,
-			Namespaces:       [][]byte{c.namespace.Bytes()},
-			ShareCommitments: [][]byte{commitment},
-			BlobSizes:        []uint32{dataLength},
-			ShareVersions:    []uint32{uint32(blob.ShareVersion())},
-		},
-		Blob: &celestiatypes.Blob{
-			NamespaceId:      blob.Namespace().ID(),
-			Data:             blob.Data(),
-			ShareVersion:     uint32(blob.ShareVersion()),
-			NamespaceVersion: uint32(blob.Namespace().Version()),
-		},
-	}, nil
-}
-
 func (c Celestia) NamespaceID() []byte {
 	chainIDhash := sha256.Sum256([]byte(c.batch.ChainID()))
 	return chainIDhash[:10]
 }
 
-func (c Celestia) GetAddress() (sdk.AccAddress, error) {
+func (c Celestia) BaseAccountAddress() (string, error) {
 	broadcaster, err := c.node.GetBroadcaster()
 	if err != nil {
-		return nil, err
+		if errors.Is(err, types.ErrKeyNotSet) {
+			return "", nil
+		}
+		return "", err
+	}
+	account, err := broadcaster.AccountByIndex(0)
+	if err != nil {
+		return "", err
 	}
-	return broadcaster.GetAddress(), nil
+
+	sender := account.GetAddressString()
+	return sender, nil
 }
 
-func (c Celestia) GetAddressStr() (string, error) {
-	broadcaster, err := c.node.GetBroadcaster()
-	if err != nil {
-		return "", err
+func (c Celestia) keyringConfigs(baseConfig *btypes.KeyringConfig) []btypes.KeyringConfig {
+	var configs []btypes.KeyringConfig
+	if baseConfig != nil {
+		configs = append(configs, *baseConfig)
 	}
-	return broadcaster.GetAddressString()
+	return configs
 }

executor/celestia/msg.go

@@ -0,0 +1,58 @@
+package celestia
+
+import (
+	"errors"
+
+	"github.com/cometbft/cometbft/crypto/merkle"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	inclusion "github.com/celestiaorg/go-square/v2/inclusion"
+	sh "github.com/celestiaorg/go-square/v2/share"
+
+	"github.com/initia-labs/opinit-bots/types"
+	celestiatypes "github.com/initia-labs/opinit-bots/types/celestia"
+)
+
+func (c Celestia) CreateBatchMsg(rawBlob []byte) (sdk.Msg, string, error) {
+	submitter, err := c.BaseAccountAddress()
+	if err != nil {
+		if errors.Is(err, types.ErrKeyNotSet) {
+			return nil, "", nil
+		}
+		return nil, "", err
+	}
+	blob, err := sh.NewV0Blob(c.namespace, rawBlob)
+	if err != nil {
+		return nil, "", err
+	}
+	commitment, err := inclusion.CreateCommitment(blob,
+		merkle.HashFromByteSlices,
+		// https://github.com/celestiaorg/celestia-app/blob/4f4d0f7ff1a43b62b232726e52d1793616423df7/pkg/appconsts/v1/app_consts.go#L6
+		64,
+	)
+	if err != nil {
+		return nil, "", err
+	}
+
+	dataLength, err := types.SafeIntToUint32(len(blob.Data()))
+	if err != nil {
+		return nil, "", err
+	}
+
+	return &celestiatypes.MsgPayForBlobsWithBlob{
+		MsgPayForBlobs: &celestiatypes.MsgPayForBlobs{
+			Signer:           submitter,
+			Namespaces:       [][]byte{c.namespace.Bytes()},
+			ShareCommitments: [][]byte{commitment},
+			BlobSizes:        []uint32{dataLength},
+			ShareVersions:    []uint32{uint32(blob.ShareVersion())},
+		},
+		Blob: &celestiatypes.Blob{
+			NamespaceId:      blob.Namespace().ID(),
+			Data:             blob.Data(),
+			ShareVersion:     uint32(blob.ShareVersion()),
+			NamespaceVersion: uint32(blob.Namespace().Version()),
+		},
+	}, submitter, nil
+}

executor/celestia/node.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/cosmos/cosmos-sdk/client/tx"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	btypes "github.com/initia-labs/opinit-bots/node/broadcaster/types"
@@ -34,25 +33,14 @@ func (c *Celestia) BuildTxWithMessages(
 		blobMsgs = append(blobMsgs, withBlobMsg.Blob)
 	}
 
-	b := c.node.MustGetBroadcaster()
-	txf := b.GetTxf()
-
-	_, adjusted, err := b.CalculateGas(ctx, txf, pfbMsgs...)
+	broadcasterAccount, err := c.node.MustGetBroadcaster().AccountByIndex(0)
 	if err != nil {
 		return nil, "", err
 	}
-
-	txf = txf.WithGas(adjusted)
-	txb, err := txf.BuildUnsignedTx(pfbMsgs...)
+	tx, err := broadcasterAccount.SimulateAndSignTx(ctx, pfbMsgs...)
 	if err != nil {
 		return nil, "", err
 	}
-
-	if err = tx.Sign(ctx, txf, b.KeyName(), txb, false); err != nil {
-		return nil, "", err
-	}
-
-	tx := txb.GetTx()
 	txConfig := c.node.GetTxConfig()
 	txBytes, err = txutils.EncodeTx(txConfig, tx)
 	if err != nil {

executor/child/child.go

@@ -19,14 +19,14 @@ import (
 )
 
 type hostNode interface {
-	GetAddressStr() (string, error)
 	HasKey() bool
+	BaseAccountAddressString() (string, error)
 	BroadcastMsgs(btypes.ProcessedMsgs)
 	ProcessedMsgsToRawKV([]btypes.ProcessedMsgs, bool) ([]types.RawKV, error)
 	QueryLastOutput(context.Context, uint64) (*ophosttypes.QueryOutputProposalResponse, error)
 	QueryOutput(context.Context, uint64, uint64, int64) (*ophosttypes.QueryOutputProposalResponse, error)
 
-	GetMsgProposeOutput(uint64, uint64, int64, []byte) (sdk.Msg, error)
+	GetMsgProposeOutput(uint64, uint64, int64, []byte) (sdk.Msg, string, error)
 }
 
 type Child struct {
@@ -58,8 +58,16 @@ func NewChildV1(
 	}
 }
 
-func (ch *Child) Initialize(ctx context.Context, processedHeight int64, startOutputIndex uint64, host hostNode, bridgeInfo ophosttypes.QueryBridgeResponse, keyringConfig *btypes.KeyringConfig) error {
-	l2Sequence, err := ch.BaseChild.Initialize(ctx, processedHeight, startOutputIndex, bridgeInfo, keyringConfig)
+func (ch *Child) Initialize(
+	ctx context.Context,
+	processedHeight int64,
+	startOutputIndex uint64,
+	host hostNode,
+	bridgeInfo ophosttypes.QueryBridgeResponse,
+	keyringConfig *btypes.KeyringConfig,
+	oracleKeyringConfig *btypes.KeyringConfig,
+) error {
+	l2Sequence, err := ch.BaseChild.Initialize(ctx, processedHeight, startOutputIndex, bridgeInfo, keyringConfig, oracleKeyringConfig)
 	if err != nil {
 		return err
 	}