Symbiotic Relay

https://github.com/symbioticfi/awesome-relay
Admin
Symbiotic Relay is a distributed middleware mesh that derives validator sets, aggregates BLS...
Tokens:9,097
Snippets:50
Trust Score:7.1
Update:9 months ago
Show doc for...
Tokens:
Raw
### Local Network Setup (Makefile)

Source: https://github.com/symbioticfi/awesome-relay/blob/main/README.md

Spins up a local development environment using Anvil, including driver contracts, multiple relay sidecars, and sample operator roles. This is facilitated by environment variables for configuration.

```makefile
make local-setup OPERATORS=5 AGGREGATORS=3 COMMITERS=2
```

--------------------------------

### Start Sidecar Script (Shell)

Source: https://github.com/symbioticfi/awesome-relay/blob/main/README.md

A shell script template used for generating configurations and orchestrating tests for the Relay sidecar. It assists in setting up and running the sidecar in different environments.

```bash
./e2e/scripts/sidecar-start.sh --config ./configs/relay.yaml --keyfile ./keys/operator.key
```

--------------------------------

### TypeScript Client Integration using Connect RPC

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Integrate the Relay gRPC client in TypeScript applications using Connect RPC. This example demonstrates submitting a signature request and watching for aggregation results. Ensure you have `@symbioticfi/relay-client-ts` and `@connectrpc/connect-node` installed.

```typescript
// npm install @symbioticfi/relay-client-ts

import { createPromiseClient } from "@connectrpc/connect";
import { createGrpcTransport } from "@connectrpc/connect-node";
import { RelayService } from "@symbioticfi/relay-client-ts/gen/relay/v1/relay_connect";

// Create gRPC transport
const transport = createGrpcTransport({
  baseUrl: "http://localhost:50051",
  httpVersion: "2",
});

// Create client
const client = createPromiseClient(RelayService, transport);

// Submit a signature request
async function submitSignatureRequest() {
  try {
    const response = await client.submitSignatureRequest({
      applicationId: "my-bridge-app",
      validatorSetId: "0x1234abcd...",
      messageHash: new Uint8Array(32), // 32-byte hash
      epochId: BigInt(12345),
      quorumThreshold: 6700, // 67%
    });

    console.log("Request submitted:", response.requestId);
    return response.requestId;
  } catch (error) {
    console.error("Failed to submit request:", error);
    throw error;
  }
}

// Stream aggregation results
async function watchAggregations(requestId: string) {
  const stream = client.streamAggregationResults({
    requestId,
  });

  for await (const result of stream) {
    console.log("Aggregation status:", result.status);
    console.log("Signatures collected:", result.signaturesCount);
    console.log("Voting power:", result.votingPowerPercent);

    if (result.status === "COMPLETED") {
      console.log("Proof ready:", result.proof);
      console.log("Validator set header:", result.validatorSetHeader);
      break;
    }
  }
}

// Complete usage example
async function main() {
  const requestId = await submitSignatureRequest();
  await watchAggregations(requestId);
}

main().catch(console.error);

```

--------------------------------

### Deploying and Interacting with Smart Contracts (Foundry)

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Details the process of deploying and interacting with Symbiotic Relay smart contracts using Foundry. It includes cloning the contract repository, installing dependencies, configuring deployment parameters, deploying to a testnet, and verifying signatures on-chain using `cast`.

```bash
# Clone the relay-contracts repository
git clone https://github.com/symbioticfi/relay-contracts.git
cd relay-contracts

# Install dependencies
forge install

# Configure deployment parameters
cat > deploy-config.toml <<EOF
[VotingPowerProvider]
minVotingPower = 1000000000000000000
slashingEnabled = true

[KeyRegistry]
supportedKeyTypes = ["bls-bn254", "ecdsa-secp256k1"]

[ValSetDriver]
epochDuration = 86400

[Settlement]
verifierType = "zk"
quorumThreshold = 6700
EOF

# Deploy contracts to testnet
forge script script/relay-deploy.sh \
  --rpc-url $SEPOLIA_RPC_URL \
  --private-key $DEPLOYER_PRIVATE_KEY \
  --broadcast \
  --verify

# Verify a BLS signature on-chain using cast
cast call $SETTLEMENT_ADDRESS \
  "verifySignature(bytes32,bytes,bytes32)" \
  0x1234567890abcdef... \
  0xabcdef1234567890... \
  0x9876543210fedcba...
```

--------------------------------

### Configuring and Running Relay Sidecar Node

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Illustrates how to configure a relay sidecar node using a YAML file and override settings with environment variables or command-line flags. It shows the structure of a `config.yaml` file and commands to start the sidecar with different configuration methods.

```yaml
# config.yaml
log:
  level: info
  mode: json

secret-keys:
  - type: bls-bn254
    hex: "0x1234567890abcdef..." # BLS private key for signing

driver:
  chain-id: 1
  address: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1" # ValSet driver contract
  rpc-url: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"

p2p:
  listen: "/ip4/0.0.0.0/tcp/9000"
  bootnodes:
    - "/ip4/34.123.45.67/tcp/9000/p2p/QmPeerID..."
  dht-mode: server

evm:
  chains:
    - id: 1
      rpc-url: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
    - id: 42161
      rpc-url: "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY"
  max-calls: 100

metrics:
  listen: "0.0.0.0:9090"
  pprof: true
```

```bash
# Start relay sidecar with config file
./relay_sidecar --config config.yaml

# Override config with environment variables
export SYMB_LOG_LEVEL=debug
export SYMB_DRIVER_CHAIN_ID=1
./relay_sidecar --config config.yaml

# Start with CLI flags (highest priority)
./relay_sidecar \
  --config config.yaml \
  --log.level=debug \
  --p2p.listen="/ip4/0.0.0.0/tcp/9000"
```

--------------------------------

### Docker Compose Setup for SymbioticFi Relay

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Defines the services required to run the SymbioticFi Relay network, including an Anvil testnet node, relay operator instances, and an aggregator. It specifies Docker images, commands, ports, volumes, and dependencies.

```yaml
version: '3.8'

services:
  anvil:
    image: ghcr.io/foundry-rs/foundry:latest
    command: anvil --host 0.0.0.0 --block-time 2
    ports:
      - "8545:8545"

  relay-operator-1:
    image: symbioticfi/relay:latest
    command: relay_sidecar --config /config/operator-1.yaml
    volumes:
      - ./configs:/config
      - ./keys:/keys
    environment:
      - SYMB_LOG_LEVEL=debug
      - SYMB_DRIVER_RPC_URL=http://anvil:8545
    depends_on:
      - anvil
    ports:
      - "50051:50051"
      - "9000:9000"

  relay-operator-2:
    image: symbioticfi/relay:latest
    command: relay_sidecar --config /config/operator-2.yaml
    volumes:
      - ./configs:/config
      - ./keys:/keys
    environment:
      - SYMB_LOG_LEVEL=debug
      - SYMB_DRIVER_RPC_URL=http://anvil:8545
    depends_on:
      - anvil
      - relay-operator-1
    ports:
      - "50052:50051"
      - "9001:9000"

  relay-aggregator:
    image: symbioticfi/relay:latest
    command: relay_sidecar --config /config/aggregator.yaml
    volumes:
      - ./configs:/config
      - ./keys:/keys
    environment:
      - SYMB_LOG_LEVEL=info
      - SYMB_DRIVER_RPC_URL=http://anvil:8545
    depends_on:
      - relay-operator-1
      - relay-operator-2
    ports:
      - "50053:50051"
```

--------------------------------

### Rust Client Integration

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Use the Relay client in Rust applications with the Tonic gRPC framework. This section provides instructions for Cargo.toml dependencies and a full example of client usage.

```APIDOC
## Rust Client Integration

### Description
Use the Relay client in Rust applications with the Tonic gRPC framework.

### Method
POST

### Endpoint
/relay.v1.RelayService/SubmitSignatureRequest

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **application_id** (String) - Required - The ID of the application submitting the request.
- **validator_set_id** (Vec<u8>) - Required - The ID of the validator set to be used (as bytes).
- **message_hash** (Vec<u8>) - Required - The 32-byte hash of the message to be signed.
- **epoch_id** (i64) - Required - The epoch ID for the signature request.
- **quorum_threshold** (u32) - Required - The quorum threshold for signature collection (e.g., 6700 for 67%).
- **unsigner_policy** (Option<UnsignerPolicyEnum>) - Optional - Policy for unsigners.

### Request Example
```rust
use symbiotic_relay_client::relay::v1::SubmitSignatureRequestRequest;

let request = SubmitSignatureRequestRequest {
    application_id: "rust-oracle".to_string(),
    validator_set_id: vec![0x12, 0x34, 0xab, 0xcd],
    message_hash: vec![0u8; 32],
    epoch_id: 12345,
    quorum_threshold: 6700,
    unsigner_policy: None,
};
```

### Response
#### Success Response (200)
- **request_id** (String) - The ID of the submitted request.

#### Response Example
```json
{
  "request_id": "unique-request-id-456"
}
```

## Rust Client Integration - Stream Aggregation Results

### Description
Stream aggregation results for a given request ID in Rust applications using the Tonic gRPC framework.

### Method
POST

### Endpoint
/relay.v1.RelayService/StreamAggregationResults

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **request_id** (String) - Required - The ID of the request for which to stream results.

### Request Example
```rust
use symbiotic_relay_client::relay::v1::StreamAggregationResultsRequest;

let stream_request = StreamAggregationResultsRequest {
    request_id: "unique-request-id-456".to_string(),
};
```

### Response
#### Success Response (200) - Stream
- **status** (i32) - The current status of the aggregation (e.g., 0: PENDING, 1: COLLECTING, 2: COMPLETED).
- **signatures_count** (u32) - The number of signatures collected so far.
- **voting_power_percent** (f32) - The percentage of voting power represented by the collected signatures.
- **proof** (Vec<u8>) - The aggregated proof, available when the status is COMPLETED.
- **validator_set_header** (ValidatorSetHeader) - The header of the validator set, available when the status is COMPLETED.

#### Response Example (Individual Stream Message)
```json
{
  "status": 1,
  "signatures_count": 15,
  "voting_power_percent": 60.0
}
```

#### Response Example (Completed Stream Message)
```json
{
  "status": 2,
  "signatures_count": 50,
  "voting_power_percent": 100.0,
  "proof": "0x...",
  "validator_set_header": {
    "height": 12345,
    "hash": "0x..."
  }
}
```
```

--------------------------------

### Setup Local Relay Network with Docker Compose

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Provides a Docker Compose configuration to run a complete Relay network locally. This is useful for testing and development environments, allowing developers to simulate the Relay ecosystem without deploying to a live network. No specific code is provided, only the configuration context.

```yaml
## Docker Compose configuration for local Relay network
# This file is intended to be used with Docker Compose to spin up
# a local instance of the Relay network for development and testing.
#
# Example usage:
# docker-compose up -d
#
# To stop the network:
# docker-compose down

version: '3.8'

services:
  relay-node:
    image: symbioticfi/relay:latest
    ports:
      - "50051:50051" # gRPC port
      - "8080:8080"   # HTTP API port (if applicable)
    volumes:
      - ./relay-config:/app/config
    environment:
      - RELAY_NODE_KEY=your_private_key_here
      - RELAY_NETWORK_ID=local
    networks:
      - relay-net

  # Add other services as needed, e.g., database, monitoring, etc.
  # database:
  #   image: postgres:13
  #   environment:
  #     POSTGRES_DB: relaydb
  #     POSTGRES_USER: user
  #     POSTGRES_PASSWORD: password
  #   volumes:
  #     - postgres_data:/var/lib/postgresql/data
  #   networks:
  #     - relay-net

networks:
  relay-net:
    driver: bridge

# volumes:
#   postgres_data:

```

--------------------------------

### Rust Client Integration using Tonic gRPC

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Integrate the Relay gRPC client in Rust applications using the Tonic gRPC framework. This example shows how to connect to the relay, submit a signature request, and stream aggregation results. Ensure you have the `symbiotic-relay-client`, `tokio`, and `tonic` crates added to your `Cargo.toml`.

```rust
use symbiotic_relay_client::relay::v1::relay_service_client::RelayServiceClient;
use symbiotic_relay_client::relay::v1::{
    SubmitSignatureRequestRequest,
    StreamAggregationResultsRequest,
};
use tonic::transport::Channel;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to relay sidecar
    let channel = Channel::from_static("http://localhost:50051")
        .connect()
        .await?;

    let mut client = RelayServiceClient::new(channel);

    // Submit signature request
    let request = tonic::Request::new(SubmitSignatureRequestRequest {
        application_id: "rust-oracle".to_string(),
        validator_set_id: vec![0x12, 0x34, 0xab, 0xcd],
        message_hash: vec![0u8; 32],
        epoch_id: 12345,
        quorum_threshold: 6700,
        unsigner_policy: None,
    });

    let response = client.submit_signature_request(request).await?;
    let request_id = response.into_inner().request_id;
    println!("Submitted request: {}", request_id);

    // Stream aggregation results
    let stream_request = tonic::Request::new(StreamAggregationResultsRequest {
        request_id: request_id.clone(),
    });

    let mut stream = client
        .stream_aggregation_results(stream_request)
        .await?
        .into_inner();

    while let Some(result) = stream.message().await? {
        println!("Status: {:?}", result.status);
        println!("Signatures: {}", result.signatures_count);

        if result.status == 2 {  // COMPLETED
            println!("Proof: {:?}", result.proof);
            break;
        }
    }

    Ok(())
}

```

```toml
# Cargo.toml
[dependencies]
symbiotic-relay-client = "0.3.0"
tokio = { version = "1", features = ["full"] }
tonic = "0.11"

```

--------------------------------

### TypeScript Client Integration

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Integrate the Relay gRPC client in TypeScript applications using Connect RPC. This section covers installation, client creation, submitting signature requests, and streaming aggregation results.

```APIDOC
## TypeScript Client Integration

### Description
Integrate the Relay gRPC client in TypeScript applications using Connect RPC.

### Method
POST

### Endpoint
/relay.v1.RelayService/SubmitSignatureRequest

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **applicationId** (string) - Required - The ID of the application submitting the request.
- **validatorSetId** (string) - Required - The ID of the validator set to be used.
- **messageHash** (Uint8Array) - Required - The 32-byte hash of the message to be signed.
- **epochId** (BigInt) - Required - The epoch ID for the signature request.
- **quorumThreshold** (number) - Required - The quorum threshold for signature collection (e.g., 6700 for 67%).

### Request Example
```json
{
  "applicationId": "my-bridge-app",
  "validatorSetId": "0x1234abcd...",
  "messageHash": "0x...", // Base64 or Uint8Array representation
  "epochId": 12345,
  "quorumThreshold": 6700
}
```

### Response
#### Success Response (200)
- **requestId** (string) - The ID of the submitted request.

#### Response Example
```json
{
  "requestId": "unique-request-id-123"
}
```

## TypeScript Client Integration - Stream Aggregation Results

### Description
Stream aggregation results for a given request ID. This endpoint allows clients to monitor the progress of signature aggregation and retrieve the final proof once completed.

### Method
POST

### Endpoint
/relay.v1.RelayService/StreamAggregationResults

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **requestId** (string) - Required - The ID of the request for which to stream results.

### Request Example
```json
{
  "requestId": "unique-request-id-123"
}
```

### Response
#### Success Response (200) - Stream
- **status** (string) - The current status of the aggregation (e.g., PENDING, COMPLETED).
- **signaturesCount** (number) - The number of signatures collected so far.
- **votingPowerPercent** (number) - The percentage of voting power represented by the collected signatures.
- **proof** (string) - The aggregated proof, available when the status is COMPLETED.
- **validatorSetHeader** (object) - The header of the validator set, available when the status is COMPLETED.

#### Response Example (Individual Stream Message)
```json
{
  "status": "COLLECTING",
  "signaturesCount": 10,
  "votingPowerPercent": 45.5
}
```

#### Response Example (Completed Stream Message)
```json
{
  "status": "COMPLETED",
  "signaturesCount": 50,
  "votingPowerPercent": 100.0,
  "proof": "0x...",
  "validatorSetHeader": {
    "height": 12345,
    "hash": "0x..."
  }
}
```
```

--------------------------------

### Cloning and Building Core Relay Implementation (Go)

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Demonstrates how to clone the Symbiotic Relay Go repository, build the relay sidecar binary for Linux, pull the official Docker image, and set up a local test network using Anvil. It includes commands for cloning, building, pulling Docker images, and configuring local test environments with adjustable parameters.

```bash
# Clone the relay repository
git clone https://github.com/symbioticfi/relay.git
cd relay

# Build the relay sidecar binary for Linux
make build-relay-sidecar OS=linux ARCH=amd64

# Or pull the official Docker image
docker pull symbioticfi/relay:latest

# Set up a local test network with Anvil
make local-setup

# Configure number of operators and aggregators
OPERATORS=5 AGGREGATORS=2 COMMITERS=1 make local-setup
```

--------------------------------

### Build Relay Sidecar Binary (Makefile)

Source: https://github.com/symbioticfi/awesome-relay/blob/main/README.md

Builds the `relay_sidecar` binary for a specified operating system and architecture. This is useful for local development or custom deployments.

```makefile
make build-relay-sidecar OS=linux ARCH=amd64
```

--------------------------------

### Relay Smart Contract Deployment (Shell)

Source: https://github.com/symbioticfi/awesome-relay/blob/main/README.md

Orchestrates the deployment of Relay smart contracts using CreateX and TransparentUpgradeableProxy. It utilizes TOML configurations and custom Foundry hooks for a flexible deployment process.

```bash
script/relay-deploy.sh --config configs/mainnet.toml --network mainnet
```

--------------------------------

### Build Relay Docker Image (Makefile)

Source: https://github.com/symbioticfi/awesome-relay/blob/main/README.md

Builds a Docker image for the Relay, allowing for containerized deployment. The tag can be specified for versioning.

```makefile
make image TAG=dev
```

--------------------------------

### Accessing Official Documentation and Architecture

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Provides commands to access the official documentation portal and detailed architecture documentation for the Symbiotic Relay. It uses `curl` to fetch resources from specified URLs.

```bash
# Visit the official docs portal
curl -L https://docs2.symbiotic.fi/get-started/

# Access the detailed architecture documentation on DeepWiki
curl -L https://deepwiki.com/symbioticfi/relay
```

--------------------------------

### Integrate Go Client with Relay Ecosystem

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Connects to the Relay sidecar using gRPC, submits a signature request with application and validator details, and streams aggregation results. Requires the Relay Go client library.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/symbioticfi/relay/api/client"
    pb "github.com/symbioticfi/relay/api/gen/go/relay/v1"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

func main() {
    // Connect to relay sidecar
    conn, err := grpc.Dial(
        "localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()

    client := pb.NewRelayServiceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    // Submit signature request
    req := &pb.SubmitSignatureRequestRequest{
        ApplicationId:    "go-sequencer",
        ValidatorSetId:   []byte{0x12, 0x34, 0xab, 0xcd},
        MessageHash:      make([]byte, 32),
        EpochId:          12345,
        QuorumThreshold:  6700,
    }

    resp, err := client.SubmitSignatureRequest(ctx, req)
    if err != nil {
        log.Fatalf("Failed to submit: %v", err)
    }
    fmt.Printf("Request ID: %s\n", resp.RequestId)

    // Stream results
    stream, err := client.StreamAggregationResults(ctx, &pb.StreamAggregationResultsRequest{
        RequestId: resp.RequestId,
    })
    if err != nil {
        log.Fatalf("Failed to stream: %v", err)
    }

    for {
        result, err := stream.Recv()
        if err != nil {
            log.Printf("Stream ended: %v", err)
            break
        }

        fmt.Printf("Status: %v, Signatures: %d, Power: %d%%\n",
            result.Status,
            result.SignaturesCount,
            result.VotingPowerPercent,
        )

        if result.Status == pb.AggregationStatus_COMPLETED {
            fmt.Printf("Proof ready: %x\n", result.Proof)
            break
        }
    }
}
```

--------------------------------

### Forge Script for Deploying Contracts

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

A Forge script command used to deploy smart contracts to the Anvil testnet. It requires the RPC URL, a private key for the deploying account, and the `--broadcast` flag to execute the deployment.

```bash
forge script script/relay-deploy.sh \
  --rpc-url http://localhost:8545 \
  --private-key $ANVIL_PRIVATE_KEY \
  --broadcast
```

--------------------------------

### Interacting with Relay Service via cURL

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Demonstrates how to send a POST request to the Relay service to submit a signature request. It includes the endpoint, content type, and a JSON payload with required parameters like `applicationId`, `messageHash`, and `epochId`.

```bash
curl -X POST http://localhost:50051/relay.v1.RelayService/SubmitSignatureRequest \
  -H "Content-Type: application/json" \
  -d '{
    "applicationId": "test-app",
    "validatorSetId": "AAECAwQFBgc=",
    "messageHash": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
    "epochId": "100",
    "quorumThreshold": 6700
  }'
```

--------------------------------

### Claim Insurance with Relay Proof using Cast

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

This command uses `cast` to submit an insurance claim. It requires the insurance address, the function signature for claiming, and several proof-related parameters (policy ID, validator set header, aggregated proof, and flight delay data) along with the user's private key.

```bash
cast send $INSURANCE_ADDRESS \
  "claimInsurance(bytes32,bytes32,bytes,bytes)" \
  0xpolicyId... \
  0xvalidatorSetHeader... \
  0xaggregatedProof... \
  0xflightDelayData... \
  --private-key $USER_PRIVATE_KEY
```

--------------------------------

### Create Insurance Policy using Cast

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

This command uses the `cast` tool to send a transaction to create an insurance policy. It specifies the recipient address, the function signature, policy details, and the user's private key for authentication. The `--value` flag indicates the transaction fee.

```bash
cast send $INSURANCE_ADDRESS \
  "createPolicy(string,uint256,uint256)" \
  "UA1234" \
  1704153600 \
  1000000000000000000 \
  --value 0.1ether \
  --private-key $USER_PRIVATE_KEY
```

--------------------------------

### Forge Command for Deploying Insurance Contract

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

A Forge command to deploy the `FlightInsurance` smart contract. It requires the RPC URL of the target network, the private key for the deploying account, and the address of the deployed Relay settlement contract as a constructor argument.

```bash
# Deploy insurance contract
forge create FlightInsurance \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --constructor-args $RELAY_SETTLEMENT_ADDRESS
```

--------------------------------

### Solidity Flight Insurance Contract with Relay Integration

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

A Solidity smart contract demonstrating flight delay insurance. It utilizes the Symbiotic Relay's `Settlement` contract to verify oracle attestations for flight delays before processing insurance claims. The contract includes functions for creating policies and claiming insurance.

```solidity
// FlightInsurance.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@symbioticfi/relay-contracts/Settlement.sol";

contract FlightInsurance {
    Settlement public relaySettlement;

    struct Policy {
        address holder;
        string flightNumber;
        uint256 departureTime;
        uint256 premium;
        uint256 payout;
        bool claimed;
    }

    mapping(bytes32 => Policy) public policies;

    event PolicyCreated(bytes32 indexed policyId, address holder, string flight);
    event ClaimProcessed(bytes32 indexed policyId, uint256 payout);

    constructor(address _relaySettlement) {
        relaySettlement = Settlement(_relaySettlement);
    }

    function createPolicy(
        string calldata flightNumber,
        uint256 departureTime,
        uint256 payout
    ) external payable returns (bytes32) {
        require(msg.value > 0, "Premium required");
        require(departureTime > block.timestamp, "Past departure");

        bytes32 policyId = keccak256(
            abi.encodePacked(msg.sender, flightNumber, departureTime)
        );

        policies[policyId] = Policy({
            holder: msg.sender,
            flightNumber: flightNumber,
            departureTime: departureTime,
            premium: msg.value,
            payout: payout,
            claimed: false
        });

        emit PolicyCreated(policyId, msg.sender, flightNumber);
        return policyId;
    }

    function claimInsurance(
        bytes32 policyId,
        bytes32 validatorSetHeader,
        bytes calldata aggregatedProof,
        bytes calldata flightDelayData
    ) external {
        Policy storage policy = policies[policyId];
        require(policy.holder == msg.sender, "Not policy holder");
        require(!policy.claimed, "Already claimed");

        // Verify oracle attestation via Relay
        bytes32 messageHash = keccak256(flightDelayData);
        bool verified = relaySettlement.verifyAggregatedSignature(
            validatorSetHeader,
            messageHash,
            aggregatedProof
        );
        require(verified, "Invalid proof");

        // Decode delay data and process claim
        (string memory flight, uint256 delayMinutes) = abi.decode(
            flightDelayData,
            (string, uint256)
        );
        require(
            keccak256(bytes(flight)) == keccak256(bytes(policy.flightNumber)),
            "Flight mismatch"
        );
        require(delayMinutes >= 120, "Delay threshold not met");

        policy.claimed = true;
        payable(msg.sender).transfer(policy.payout);

        emit ClaimProcessed(policyId, policy.payout);
    }
}

```

--------------------------------

### Derive Validator Set Statistics with TypeScript

Source: https://context7.com/symbioticfi/awesome-relay/llms.txt

Fetches epoch data from a driver contract, derives the validator set with specified voting power rules, and computes a MiMC hash. Requires ethers.js and the @symbioticfi/relay-stats-ts library. Outputs validator set hash and extra data for aggregator submission.

```typescript
// npm install @symbioticfi/relay-stats-ts

import {
  deriveValidatorSet,
  computeMiMCHash,
  getEpochData,
  createAggregatorExtraData,
} from "@symbioticfi/relay-stats-ts";
import { ethers } from "ethers";

// Connect to provider
const provider = new ethers.JsonRpcProvider(
  "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
);

// Get epoch data from driver contract
async function getValidatorSetForEpoch() {
  const driverAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1";
  const epochId = 12345n;

  const epochData = await getEpochData(
    provider,
    driverAddress,
    epochId,
    {
      cacheProvider: null, // Optional: Redis/Memory cache
    }
  );

  console.log("Epoch start:", epochData.startBlock);
  console.log("Epoch end:", epochData.endBlock);
  console.log("Operators:", epochData.operators.length);

  return epochData;
}

// Derive validator set from epoch data
async function deriveValidators() {
  const epochData = await getValidatorSetForEpoch();

  const validatorSet = await deriveValidatorSet({
    operators: epochData.operators,
    votingPowerRules: {
      minPower: 1000000000000000000n, // 1 token minimum
      normalization: "linear",
    },
  });

  console.log("Total validators:", validatorSet.validators.length);
  console.log("Total voting power:", validatorSet.totalVotingPower);

  // Compute deterministic validator set hash
  const vsHash = computeMiMCHash(validatorSet.validators);
  console.log("Validator set hash:", vsHash);

  return { validatorSet, vsHash };
}

// Create extra data for aggregator submission
async function prepareAggregatorData() {
  const { validatorSet, vsHash } = await deriveValidators();

  const extraData = createAggregatorExtraData({
    validatorSetHash: vsHash,
    epochId: 12345n,
    signatures: [
      { validatorIndex: 0, signature: "0x1234..." },
      { validatorIndex: 1, signature: "0x5678..." },
      { validatorIndex: 3, signature: "0xabcd..." },
    ],
    quorumThreshold: 6700,
  });

  console.log("Extra data for submission:", extraData);
  return extraData;
}

prepareAggregatorData().catch(console.error);
```
Tokens:
Raw