Merge pull request #16 from automata-network/dev

v0.1.3

Author: chzyer

.gitignore

@@ -14,3 +14,4 @@ docs/
 # Dotenv file
 .env
 config/operator_task_fetcher.offset
+.DS_Store

.gitmodules

@@ -17,3 +17,6 @@
 	path = sgx-prover
 	url = [email protected]:automata-network/sgx-prover.git
 	branch = avs
+[submodule "linea-sgx-prover"]
+	path = linea-sgx-prover
+	url = [email protected]:automata-network/linea-sgx-prover.git

README.md

@@ -152,55 +152,16 @@ Please visit the [Operator setup](https://github.com/automata-network/multiprove
 
 The Multi-Prover AVS will launch on mainnet soon, please be patient!
 
-## Quick Start
+## Compile From Source
 
-Steps for running the multi-prover-avs in simulation node(without the SGX prover):
+### Operator
 
-1. Start a execution node
 ```
-> anvil --fork-url ${holesky_rpc_endpoint} --fork-block-number 1218851
+go build -o out/operator ./cmd/operator
 ```
 
-2. Prepare the environment
-```
-> cp .env.example .env
-> # vim .env
-```
-
-3. Deploy the avs contracts
-```
-> ./script/deploy.sh init_all --simulation
-> # this script will update the configure on config/operator.json and config/aggregator.json
-```
-
-4. Run the aggregator
-```
-go run ./cmd/aggregator
-```
-
-5. Run the operator
-```
-go run ./cmd/operator
-```
-
-### With Docker compose
-
-1. build image
-```
-> ./script/docker.sh build
-```
+### Aggregator
 
-2. init state
 ```
-> ./scripts/docker.sh init_state --simulation
-```
-
-3. start aggregator & operator
-```
-> ./scripts/docker.sh run
-```
-
-3. stop all
+go build -o out/aggregator ./cmd/aggregator
 ```
-> ./scripts/docker.sh stop
-```

aggregator/aggregator.go

@@ -2,18 +2,18 @@ package aggregator
 
 import (
 	"context"
-	"math/big"
+	"encoding/json"
 	"net"
 	"net/http"
 	"os"
 	"sync"
 	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
-	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
 	"github.com/Layr-Labs/eigensdk-go/services/avsregistry"
 	blsagg "github.com/Layr-Labs/eigensdk-go/services/bls_aggregation"
 	"github.com/Layr-Labs/eigensdk-go/types"
+	"github.com/automata-network/multi-prover-avs/contracts/bindings"
 	"github.com/automata-network/multi-prover-avs/contracts/bindings/MultiProverServiceManager"
 	"github.com/automata-network/multi-prover-avs/contracts/bindings/TEELivenessVerifier"
 	"github.com/automata-network/multi-prover-avs/utils"
@@ -32,13 +32,15 @@ type Config struct {
 	EcdsaPrivateKey                    string
 	EthHttpEndpoint                    string
 	EthWsEndpoint                      string
+	AttestationLayerRpcURL             string
 	MultiProverContractAddress         common.Address
 	TEELivenessVerifierContractAddress common.Address
 
 	AVSRegistryCoordinatorAddress common.Address
 	OperatorStateRetrieverAddress common.Address
 	EigenMetricsIpPortAddress     string
 	ScanStartBlock                uint64
+	Threshold                     uint64
 
 	Simulation bool
 }
@@ -55,6 +57,8 @@ type Aggregator struct {
 	TEELivenessVerifier *TEELivenessVerifier.TEELivenessVerifierCaller
 	registry            *avsregistry.AvsRegistryServiceChainCaller
 
+	eigenClients *clients.Clients
+
 	taskMutex    sync.Mutex
 	taskIndexSeq uint32
 	taskIndexMap map[types.TaskResponseDigest]*Task
@@ -74,6 +78,10 @@ func NewAggregator(ctx context.Context, cfg *Config) (*Aggregator, error) {
 	if err != nil {
 		return nil, logex.Trace(err)
 	}
+	attestationClient, err := ethclient.Dial(cfg.AttestationLayerRpcURL)
+	if err != nil {
+		return nil, logex.Trace(err, cfg.AttestationLayerRpcURL)
+	}
 	chainId, err := client.ChainID(ctx)
 	if err != nil {
 		return nil, logex.Trace(err)
@@ -109,7 +117,7 @@ func NewAggregator(ctx context.Context, cfg *Config) (*Aggregator, error) {
 	if err != nil {
 		return nil, logex.Trace(err)
 	}
-	TEELivenessVerifier, err := TEELivenessVerifier.NewTEELivenessVerifierCaller(cfg.TEELivenessVerifierContractAddress, client)
+	TEELivenessVerifier, err := TEELivenessVerifier.NewTEELivenessVerifierCaller(cfg.TEELivenessVerifierContractAddress, attestationClient)
 	if err != nil {
 		return nil, logex.Trace(err)
 	}
@@ -181,7 +189,7 @@ func (agg *Aggregator) Start(ctx context.Context) error {
 			delete(agg.taskIndexMap, response.TaskResponseDigest)
 			agg.taskMutex.Unlock()
 
-			if err := agg.sendAggregatedResponseToContract(task, response); err != nil {
+			if err := agg.sendAggregatedResponseToContract(ctx, task, response); err != nil {
 				logex.Error(err)
 			}
 		case err := <-errChan:
@@ -191,10 +199,31 @@ func (agg *Aggregator) Start(ctx context.Context) error {
 }
 
 func (agg *Aggregator) submitStateHeader(ctx context.Context, req *TaskRequest) error {
+	if req.Task.Identifier.ToInt().Int64() == 1 {
+		var md Metadata
+		if err := json.Unmarshal([]byte(req.Task.Metadata), &md); err != nil {
+			return logex.Trace(err)
+		}
+		if md.BatchId > 0 {
+			if md.BatchId%2000 != 0 {
+				logex.Info("[scroll] skip task: %#v", md)
+				return nil
+			}
+		}
+	}
 	digest, err := req.Task.Digest()
 	if err != nil {
 		return logex.Trace(err)
 	}
+
+	quorumNumbers := make([]types.QuorumNum, len(req.Task.QuorumNumbers))
+	quorumThresholdPercentages := make([]types.QuorumThresholdPercentage, len(req.Task.QuorumThresholdPercentages))
+	for i, qn := range req.Task.QuorumNumbers {
+		quorumNumbers[i] = types.QuorumNum(qn)
+		quorumThresholdPercentages[i] = types.QuorumThresholdPercentage(agg.cfg.Threshold)
+	}
+	req.Task.QuorumThresholdPercentages = types.QuorumThresholdPercentages(quorumThresholdPercentages).UnderlyingType()
+
 	agg.taskMutex.Lock()
 	task, ok := agg.taskIndexMap[digest]
 	if !ok {
@@ -209,16 +238,7 @@ func (agg *Aggregator) submitStateHeader(ctx context.Context, req *TaskRequest)
 
 	if !ok {
 		timeToExpiry := time.Duration(agg.cfg.TimeToExpirySecs) * time.Second
-		sh := req.Task
-		quorumNumbers := make([]types.QuorumNum, len(sh.QuorumNumbers))
-		quorumThresholdPercentages := make([]types.QuorumThresholdPercentage, len(sh.QuorumThresholdPercentages))
-		for i, qn := range sh.QuorumNumbers {
-			quorumNumbers[i] = types.QuorumNum(qn)
-		}
-		for i, qn := range sh.QuorumThresholdPercentages {
-			quorumThresholdPercentages[i] = types.QuorumThresholdPercentage(qn)
-		}
-		err = agg.blsAggregationService.InitializeNewTask(task.index, sh.ReferenceBlockNumber, quorumNumbers, quorumThresholdPercentages, timeToExpiry)
+		err = agg.blsAggregationService.InitializeNewTask(task.index, req.Task.ReferenceBlockNumber, quorumNumbers, quorumThresholdPercentages, timeToExpiry)
 		if err != nil {
 			return logex.Trace(err)
 		}
@@ -230,24 +250,24 @@ func (agg *Aggregator) submitStateHeader(ctx context.Context, req *TaskRequest)
 	return nil
 }
 
-func (agg *Aggregator) sendAggregatedResponseToContract(task *Task, blsAggServiceResp blsagg.BlsAggregationServiceResponse) error {
+func (agg *Aggregator) sendAggregatedResponseToContract(ctx context.Context, task *Task, blsAggServiceResp blsagg.BlsAggregationServiceResponse) error {
 	if blsAggServiceResp.Err != nil {
 		return logex.Trace(blsAggServiceResp.Err)
 	}
 
 	nonSignerPubkeys := []MultiProverServiceManager.BN254G1Point{}
 	for _, nonSignerPubkey := range blsAggServiceResp.NonSignersPubkeysG1 {
-		nonSignerPubkeys = append(nonSignerPubkeys, ConvertToBN254G1Point(nonSignerPubkey))
+		nonSignerPubkeys = append(nonSignerPubkeys, bindings.ConvertToBN254G1Point(nonSignerPubkey))
 	}
 	quorumApks := []MultiProverServiceManager.BN254G1Point{}
 	for _, quorumApk := range blsAggServiceResp.QuorumApksG1 {
-		quorumApks = append(quorumApks, ConvertToBN254G1Point(quorumApk))
+		quorumApks = append(quorumApks, bindings.ConvertToBN254G1Point(quorumApk))
 	}
 	nonSignerStakesAndSignature := MultiProverServiceManager.IBLSSignatureCheckerNonSignerStakesAndSignature{
 		NonSignerPubkeys:             nonSignerPubkeys,
 		QuorumApks:                   quorumApks,
-		ApkG2:                        ConvertToBN254G2Point(blsAggServiceResp.SignersApkG2),
-		Sigma:                        ConvertToBN254G1Point(blsAggServiceResp.SignersAggSigG1.G1Point),
+		ApkG2:                        bindings.ConvertToBN254G2Point(blsAggServiceResp.SignersApkG2),
+		Sigma:                        bindings.ConvertToBN254G1Point(blsAggServiceResp.SignersAggSigG1.G1Point),
 		NonSignerQuorumBitmapIndices: blsAggServiceResp.NonSignerQuorumBitmapIndices,
 		QuorumApkIndices:             blsAggServiceResp.QuorumApkIndices,
 		TotalStakeIndices:            blsAggServiceResp.TotalStakeIndices,
@@ -260,21 +280,23 @@ func (agg *Aggregator) sendAggregatedResponseToContract(task *Task, blsAggServic
 	}
 	logex.Pretty(task.state.Task)
 	logex.Infof("confirm state: %v", tx.Hash())
+	go func() {
+		ctx, cancel := context.WithTimeout(ctx, 300*time.Second)
+		defer cancel()
+		for {
+			select {
+			case <-ctx.Done():
+				logex.Error(ctx.Err())
+			default:
+				receipt, _ := agg.client.TransactionReceipt(ctx, tx.Hash())
+				if receipt != nil {
+					logex.Infof("tx commited: %v, gas used: %v, success: %v", tx.Hash(), receipt.GasUsed, receipt.Status == 1)
+					return
+				}
+				time.Sleep(3 * time.Second)
+				continue
+			}
+		}
+	}()
 	return nil
 }
-
-func ConvertToBN254G1Point(input *bls.G1Point) MultiProverServiceManager.BN254G1Point {
-	output := MultiProverServiceManager.BN254G1Point{
-		X: input.X.BigInt(big.NewInt(0)),
-		Y: input.Y.BigInt(big.NewInt(0)),
-	}
-	return output
-}
-
-func ConvertToBN254G2Point(input *bls.G2Point) MultiProverServiceManager.BN254G2Point {
-	output := MultiProverServiceManager.BN254G2Point{
-		X: [2]*big.Int{input.X.A1.BigInt(big.NewInt(0)), input.X.A0.BigInt(big.NewInt(0))},
-		Y: [2]*big.Int{input.Y.A1.BigInt(big.NewInt(0)), input.Y.A0.BigInt(big.NewInt(0))},
-	}
-	return output
-}

aggregator/aggregator_api.go

@@ -65,7 +65,7 @@ func (a *AggregatorApi) submitTask(ctx context.Context, req *TaskRequest) error
 		return logex.Trace(err)
 	}
 	if !pass {
-		return logex.NewErrorf("prover not registered")
+		return logex.NewErrorf("prover[%v] not registered", req.OperatorId)
 	}
 
 	if err := a.agg.submitStateHeader(ctx, req); err != nil {

aggregator/client.go

@@ -17,6 +17,7 @@ type Client struct {
 }
 
 func NewClient(endpoint string) (*Client, error) {
+	logex.Infof("connecting to aggregator: %v", endpoint)
 	client, err := rpc.Dial(endpoint)
 	if err != nil {
 		return nil, logex.Trace(err)
@@ -26,6 +27,12 @@ func NewClient(endpoint string) (*Client, error) {
 	}, nil
 }
 
+type Metadata struct {
+	BatchId    uint64 `json:"batch_id,omitempty"`
+	StartBlock uint64 `json:"start_block"`
+	EndBlock   uint64 `json:"end_block"`
+}
+
 type TaskRequest struct {
 	Task       *StateHeader
 	Signature  *bls.Signature
@@ -43,7 +50,7 @@ type StateHeader struct {
 
 func (s *StateHeader) ToAbi() *bindings.StateHeader {
 	return &bindings.StateHeader{
-		Identifier:                 new(big.Int).Set((*big.Int)(s.Identifier)),
+		CommitteeId:                new(big.Int).Set((*big.Int)(s.Identifier)),
 		Metadata:                   []byte(s.Metadata),
 		State:                      []byte(s.State),
 		QuorumNumbers:              []byte(s.QuorumNumbers),

cmd/abigen/main.go

@@ -10,13 +10,23 @@ import (
 )
 
 func main() {
-	if err := gen("contracts/bindings", "contracts/out/", "MultiProverServiceManager"); err != nil {
+	target := "contracts/bindings"
+	if err := gen(target, "contracts/out/", "MultiProverServiceManager"); err != nil {
 		logex.Fatal(err)
 	}
-	if err := gen("contracts/bindings", "contracts/dcap-v3-attestation/out/", "AutomataDcapV3Attestation"); err != nil {
+	if err := gen(target, "contracts/dcap-v3-attestation/out/", "AutomataDcapV3Attestation"); err != nil {
 		logex.Fatal(err)
 	}
-	if err := gen("contracts/bindings", "contracts/out/", "TEELivenessVerifier"); err != nil {
+	if err := gen(target, "contracts/out/", "TEELivenessVerifier"); err != nil {
+		logex.Fatal(err)
+	}
+	if err := gen(target, "contracts/out/", "BLSApkRegistry"); err != nil {
+		logex.Fatal(err)
+	}
+	if err := gen(target, "contracts/out/", "RegistryCoordinator"); err != nil {
+		logex.Fatal(err)
+	}
+	if err := gen(target, "contracts/out/ERC20", "ERC20"); err != nil {
 		logex.Fatal(err)
 	}
 }

cmd/aggregator/Dockerfile

@@ -12,6 +12,7 @@ COPY contracts/bindings ./contracts/bindings
 COPY utils ./utils
 COPY go.mod ./
 COPY go.sum ./
+COPY vendor ./vendor
 
 
 RUN go build -o ./bin/aggregator ./cmd/aggregator

cmd/operator/Dockerfile

@@ -13,9 +13,16 @@ COPY contracts/bindings ./contracts/bindings
 COPY utils ./utils
 COPY go.mod ./
 COPY go.sum ./
+COPY vendor ./vendor
 
+ARG BUILD_TAG
+ARG GIT_COMMIT
+ARG GIT_DATE
+ENV BUILD_TAG $BUILD_TAG
+ENV GIT_COMMIT $GIT_COMMIT
+ENV GIT_DATE $GIT_DATE
 
-RUN go build -o ./bin/operator ./cmd/operator
+RUN go build -ldflags "-X main.SemVer=${BUILD_TAG} -X main.GitCommit=${GIT_COMMIT} -X main.GitDate=${GIT_DATE}" -o ./bin/operator ./cmd/operator
 
 FROM alpine:3.18