Skip to content

Commit

Permalink
feat: v3.5.0-rc2 merge - update eigenda challenge test
Browse files Browse the repository at this point in the history
  • Loading branch information
@ethenotethan
ethenotethan committed Feb 6, 2025
1 parent 3d9260e commit 9acf242
Showing 1 changed file with 125 additions and 127 deletions.
252 changes: 125 additions & 127 deletions system_tests/full_challenge_impl_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,8 +27,8 @@ import (
"github.com/offchainlabs/nitro/arbnode"
"github.com/offchainlabs/nitro/arbos"
"github.com/offchainlabs/nitro/arbstate"
// "github.com/offchainlabs/nitro/arbstate/daprovider"
// "github.com/offchainlabs/nitro/eigenda"
"github.com/offchainlabs/nitro/arbstate/daprovider"
"github.com/offchainlabs/nitro/eigenda"
"github.com/offchainlabs/nitro/solgen/go/challengegen"
"github.com/offchainlabs/nitro/solgen/go/mocksgen"

Expand Down Expand Up @@ -181,99 +181,99 @@ func makeBatch(t *testing.T, l2Node *arbnode.Node, l2Info *BlockchainTestInfo, b
Require(t, err, "failed to get batch metadata after adding batch:")
}

// func makeBatchEigenDA(t *testing.T, l2Node *arbnode.Node, l2Info *BlockchainTestInfo, backend *ethclient.Client, sequencer *bind.TransactOpts, seqInbox *mocksgen.SequencerInboxStub, seqInboxAddr common.Address, modStep int64) {
// ctx := context.Background()

// batchBuffer := bytes.NewBuffer([]byte{})
// for i := int64(0); i < makeBatch_MsgsPerBatch; i++ {
// value := i
// if i == modStep {
// value++
// }
// err := writeTxToBatch(batchBuffer, l2Info.PrepareTx("Owner", "Destination", 1000000, big.NewInt(value), []byte{}))
// Require(t, err)
// }
// compressed, err := arbcompress.CompressWell(batchBuffer.Bytes())
// Require(t, err)
// message := append([]byte{0}, compressed...)

// seqNum := new(big.Int).Lsh(common.Big1, 256)
// seqNum.Sub(seqNum, common.Big1)

// // disperse batch to eigenda-proxy

// eigenDA, err := eigenda.NewEigenDA(&eigenda.EigenDAConfig{
// Enable: true,
// Rpc: "http://localhost:4242",
// })

// Require(t, err)

// blobInfo, err := eigenDA.Store(ctx, message)
// Require(t, err)

// bh := mocksgen.IEigenDAServiceManagerBatchHeader{
// BlobHeadersRoot: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.BlobHeadersRoot,
// QuorumNumbers: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.QuorumNumbers,
// SignedStakeForQuorums: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.SignedStakeForQuorums,
// ReferenceBlockNumber: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.ReferenceBlockNumber,
// }

// bm := mocksgen.IEigenDAServiceManagerBatchMetadata{
// BatchHeader: bh,
// SignatoryRecordHash: blobInfo.BlobVerificationProof.BatchMetadata.SignatoryRecordHash,
// ConfirmationBlockNumber: blobInfo.BlobVerificationProof.BatchMetadata.ConfirmationBlockNumber,
// }

// bvp := mocksgen.EigenDARollupUtilsBlobVerificationProof{
// BatchId: blobInfo.BlobVerificationProof.BatchID,
// BlobIndex: blobInfo.BlobVerificationProof.BlobIndex,
// BatchMetadata: bm,
// InclusionProof: blobInfo.BlobVerificationProof.InclusionProof,
// QuorumIndices: blobInfo.BlobVerificationProof.QuorumIndices,
// }

// solQps := make([]mocksgen.IEigenDAServiceManagerQuorumBlobParam, len(blobInfo.BlobHeader.QuorumBlobParams))
// for _, qp := range blobInfo.BlobHeader.QuorumBlobParams {
// solQps = append(solQps, mocksgen.IEigenDAServiceManagerQuorumBlobParam{
// QuorumNumber: qp.QuorumNumber,
// AdversaryThresholdPercentage: qp.AdversaryThresholdPercentage,
// ConfirmationThresholdPercentage: qp.ConfirmationThresholdPercentage,
// ChunkLength: qp.ChunkLength,
// })
// }

// blobHeader := mocksgen.IEigenDAServiceManagerBlobHeader{
// Commitment: mocksgen.BN254G1Point{
// X: blobInfo.BlobHeader.Commitment.X,
// Y: blobInfo.BlobHeader.Commitment.Y,
// },
// DataLength: blobInfo.BlobHeader.DataLength,
// QuorumBlobParams: solQps,
// }

// daCert := mocksgen.ISequencerInboxEigenDACert{
// BlobVerificationProof: bvp,
// BlobHeader: blobHeader,
// }

// tx, err := seqInbox.AddSequencerL2BatchFromEigenDA(sequencer, seqNum, daCert, common.Address{}, big.NewInt(1), big.NewInt(0), big.NewInt(0))
// Require(t, err)
// receipt, err := EnsureTxSucceeded(ctx, backend, tx)
// Require(t, err)

// nodeSeqInbox, err := arbnode.NewSequencerInbox(backend, seqInboxAddr, 0)
// Require(t, err)
// batches, err := nodeSeqInbox.LookupBatchesInRange(ctx, receipt.BlockNumber, receipt.BlockNumber)
// Require(t, err)
// if len(batches) == 0 {
// Fatal(t, "batch not found after AddSequencerL2BatchFromOrigin")
// }
// err = l2Node.InboxTracker.AddSequencerBatches(ctx, backend, batches)
// Require(t, err)
// _, err = l2Node.InboxTracker.GetBatchMetadata(0)
// Require(t, err, "failed to get batch metadata after adding batch:")
// }
func makeBatchEigenDA(t *testing.T, l2Node *arbnode.Node, l2Info *BlockchainTestInfo, backend *ethclient.Client, sequencer *bind.TransactOpts, seqInbox *mocksgen.SequencerInboxStub, seqInboxAddr common.Address, modStep int64) {
ctx := context.Background()

batchBuffer := bytes.NewBuffer([]byte{})
for i := int64(0); i < makeBatch_MsgsPerBatch; i++ {
value := i
if i == modStep {
value++
}
err := writeTxToBatch(batchBuffer, l2Info.PrepareTx("Owner", "Destination", 1000000, big.NewInt(value), []byte{}))
Require(t, err)
}
compressed, err := arbcompress.CompressWell(batchBuffer.Bytes())
Require(t, err)
message := append([]byte{0}, compressed...)

seqNum := new(big.Int).Lsh(common.Big1, 256)
seqNum.Sub(seqNum, common.Big1)

// disperse batch to eigenda-proxy

eigenDA, err := eigenda.NewEigenDA(&eigenda.EigenDAConfig{
Enable: true,
Rpc: "http://localhost:4242",
})

Require(t, err)

blobInfo, err := eigenDA.Store(ctx, message)
Require(t, err)

bh := mocksgen.IEigenDAServiceManagerBatchHeader{
BlobHeadersRoot: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.BlobHeadersRoot,
QuorumNumbers: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.QuorumNumbers,
SignedStakeForQuorums: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.SignedStakeForQuorums,
ReferenceBlockNumber: blobInfo.BlobVerificationProof.BatchMetadata.BatchHeader.ReferenceBlockNumber,
}

bm := mocksgen.IEigenDAServiceManagerBatchMetadata{
BatchHeader: bh,
SignatoryRecordHash: blobInfo.BlobVerificationProof.BatchMetadata.SignatoryRecordHash,
ConfirmationBlockNumber: blobInfo.BlobVerificationProof.BatchMetadata.ConfirmationBlockNumber,
}

bvp := mocksgen.EigenDARollupUtilsBlobVerificationProof{
BatchId: blobInfo.BlobVerificationProof.BatchID,
BlobIndex: blobInfo.BlobVerificationProof.BlobIndex,
BatchMetadata: bm,
InclusionProof: blobInfo.BlobVerificationProof.InclusionProof,
QuorumIndices: blobInfo.BlobVerificationProof.QuorumIndices,
}

solQps := make([]mocksgen.IEigenDAServiceManagerQuorumBlobParam, len(blobInfo.BlobHeader.QuorumBlobParams))
for _, qp := range blobInfo.BlobHeader.QuorumBlobParams {
solQps = append(solQps, mocksgen.IEigenDAServiceManagerQuorumBlobParam{
QuorumNumber: qp.QuorumNumber,
AdversaryThresholdPercentage: qp.AdversaryThresholdPercentage,
ConfirmationThresholdPercentage: qp.ConfirmationThresholdPercentage,
ChunkLength: qp.ChunkLength,
})
}

blobHeader := mocksgen.IEigenDAServiceManagerBlobHeader{
Commitment: mocksgen.BN254G1Point{
X: blobInfo.BlobHeader.Commitment.X,
Y: blobInfo.BlobHeader.Commitment.Y,
},
DataLength: blobInfo.BlobHeader.DataLength,
QuorumBlobParams: solQps,
}

daCert := mocksgen.ISequencerInboxEigenDACert{
BlobVerificationProof: bvp,
BlobHeader: blobHeader,
}

tx, err := seqInbox.AddSequencerL2BatchFromEigenDA(sequencer, seqNum, daCert, common.Address{}, big.NewInt(1), big.NewInt(0), big.NewInt(0))
Require(t, err)
receipt, err := EnsureTxSucceeded(ctx, backend, tx)
Require(t, err)

nodeSeqInbox, err := arbnode.NewSequencerInbox(backend, seqInboxAddr, 0)
Require(t, err)
batches, err := nodeSeqInbox.LookupBatchesInRange(ctx, receipt.BlockNumber, receipt.BlockNumber)
Require(t, err)
if len(batches) == 0 {
Fatal(t, "batch not found after AddSequencerL2BatchFromOrigin")
}
err = l2Node.InboxTracker.AddSequencerBatches(ctx, backend, batches)
Require(t, err)
_, err = l2Node.InboxTracker.GetBatchMetadata(0)
Require(t, err, "failed to get batch metadata after adding batch:")
}

func confirmLatestBlock(ctx context.Context, t *testing.T, l1Info *BlockchainTestInfo, backend *ethclient.Client) {
t.Helper()
Expand Down Expand Up @@ -358,20 +358,18 @@ func RunChallengeTest(t *testing.T, asserterIsCorrect bool, useStubs bool, chall
conf.InboxReader.CheckDelay = time.Second

if useEigenDA {
// t.Log("Using EigenDA configurations for challenge test")
// builder.chainConfig = params.ArbitrumDevTestEigenDAConfig()
// builder.chainConfig.ArbitrumChainParams.EigenDA = true
// builder.nodeConfig.EigenDA = eigenda.EigenDAConfig{
// Enable: true,
// Rpc: "http://localhost:4242",
// }

// chainConfig = params.ArbitrumDevTestEigenDAConfig()
// chainConfig.ArbitrumChainParams.EigenDA = true
// conf.EigenDA = eigenda.EigenDAConfig{
// Enable: true,
// Rpc: "http://localhost:4242",
// }
t.Log("Using EigenDA configurations for challenge test")
builder.chainConfig.ArbitrumChainParams.EigenDA = true
builder.nodeConfig.EigenDA = eigenda.EigenDAConfig{
Enable: true,
Rpc: "http://localhost:4242",
}

chainConfig.ArbitrumChainParams.EigenDA = true
conf.EigenDA = eigenda.EigenDAConfig{
Enable: true,
Rpc: "http://localhost:4242",
}
}

var valStack *node.Node
Expand Down Expand Up @@ -414,11 +412,11 @@ func RunChallengeTest(t *testing.T, asserterIsCorrect bool, useStubs bool, chall

var challengerParams SecondNodeParams
if useEigenDA {
// challengerParams = SecondNodeParams{
// nodeConfig: conf,
// addresses: &challengerRollupAddresses,
// initData: &challengerL2Info.ArbInitData,
// }
challengerParams = SecondNodeParams{
nodeConfig: conf,
addresses: &challengerRollupAddresses,
initData: &challengerL2Info.ArbInitData,
}
} else {
challengerParams = SecondNodeParams{
addresses: &challengerRollupAddresses,
Expand All @@ -439,16 +437,16 @@ func RunChallengeTest(t *testing.T, asserterIsCorrect bool, useStubs bool, chall

if useEigenDA {
// seqNum := common.Big2
// makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
// makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-1)
makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-1)

// // seqNum.Add(seqNum, common.Big1)
// makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
// makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-makeBatch_MsgsPerBatch-1)
// seqNum.Add(seqNum, common.Big1)
makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-makeBatch_MsgsPerBatch-1)

// // seqNum.Add(seqNum, common.Big1)
// makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
// makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-makeBatch_MsgsPerBatch*2-1)
// seqNum.Add(seqNum, common.Big1)
makeBatchEigenDA(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
makeBatchEigenDA(t, challengerL2, challengerL2Info, l1Backend, &sequencerTxOpts, challengerSeqInbox, challengerSeqInboxAddr, challengeMsgIdx-makeBatch_MsgsPerBatch*2-1)
} else {
// seqNum := common.Big2
makeBatch(t, asserterL2, asserterL2Info, l1Backend, &sequencerTxOpts, asserterSeqInbox, asserterSeqInboxAddr, -1)
Expand Down Expand Up @@ -526,15 +524,15 @@ func RunChallengeTest(t *testing.T, asserterIsCorrect bool, useStubs bool, chall

confirmLatestBlock(ctx, t, l1Info, l1Backend)

// readers := make([]daprovider.Reader, 1)
readers := make([]daprovider.Reader, 1)
if useEigenDA {
// eigenDA, err := eigenda.NewEigenDA(&conf.EigenDA)
eigenDA, err := eigenda.NewEigenDA(&conf.EigenDA)

// Require(t, err)
// readers[0] = eigenda.NewReaderForEigenDA(eigenDA)
Require(t, err)
readers[0] = eigenda.NewReaderForEigenDA(eigenDA)
}

asserterValidator, err := staker.NewStatelessBlockValidator(asserterL2.InboxReader, asserterL2.InboxTracker, asserterL2.TxStreamer, asserterExec.Recorder, asserterL2.ArbDB, nil, StaticFetcherFrom(t, &conf.BlockValidator), valStack)
asserterValidator, err := staker.NewStatelessBlockValidator(asserterL2.InboxReader, asserterL2.InboxTracker, asserterL2.TxStreamer, asserterExec.Recorder, asserterL2.ArbDB, readers, StaticFetcherFrom(t, &conf.BlockValidator), valStack)
if err != nil {
Fatal(t, err)
}
Expand Down

0 comments on commit 9acf242

Please sign in to comment.