Relay Off-Chain

import (
    relay "github.com/symbioticfi/relay/api/client/v1"
)
 
func main() {
    relayClient = relay.NewSymbioticClient(conn)
 
    epochInfos, _ := relayClient.GetLastAllCommitted(ctx, &relay.GetLastAllCommittedRequest{})
    suggestedEpoch := epochInfos.SuggestedEpochInfo.GetLastCommittedEpoch()
 
    signMessageResponse, _ := relayClient.SignMessage(ctx, &relay.SignMessageRequest{
        KeyTag:        15, // default key tag - BN254
        Message:       encode(taskId),
        RequiredEpoch: &suggestedEpoch,
    })
 
    listenProofsRequest := &relay.ListenProofsRequest{
        StartEpoch: suggestedEpoch,
    }
    proofsStream, _ := relayClient.ListenProofs(ctx, listenProofsRequest)
    aggregationProof = []byte{}
    while proofResponse, _ := proofsStream.Recv() {
        if proofResponse.GetRequestId() == signMessageResponse.GetRequestId() {
            aggregationProof = proofResponse.GetAggregationProof().GetProof()
            break
        }
    }
 
    appContract.CompleteTask(taskId, signMessageResponse.Epoch, aggregationProof)
}

import { createClient } from "@connectrpc/connect";
import { SymbioticAPIService } from "@symbioticfi/relay-client-ts";
import {
  GetLastAllCommittedRequestSchema,
  SignMessageRequestSchema,
  ListenProofsRequestSchema,
} from "@symbioticfi/relay-client-ts";
import { create } from "@bufbuild/protobuf";
 
async function main() {
    const relayClient = createClient(SymbioticAPIService, transport);
 
    const getLastAllCommittedResponse = await relayClient.getLastAllCommitted(create(GetLastAllCommittedRequestSchema));
    const suggestedEpoch = getLastAllCommittedResponse.suggestedEpochInfo.lastCommittedEpoch;
 
    const signMessageRequest = create(SignMessageRequestSchema, {
        keyTag: 15, // default key tag - BN254
        message: encode(taskId),
        requiredEpoch: suggestedEpoch,
    });
    const signMessageResponse = await relayClient.signMessage(signMessageRequest);
 
    const listenProofsRequest = create(ListenProofsRequestSchema, { startEpoch: suggestedEpoch });
    const proofsStream = await relayClient.listenProofs(listenProofsRequest);
    let aggregationProof;
    for await (const proofResponse of proofsStream) {
        if (proofResponse.requestId === signMessageResponse.requestId) {
            aggregationProof = proofResponse.aggregationProof?.proof;
            break;
        }
    }
 
    await appContract.completeTask(taskId, signMessageResponse.epoch, aggregationProof);
}

use symbiotic_relay_client::generated::api::proto::v1::{
    GetLastAllCommittedRequest, SignMessageRequest, ListenProofsRequest,
    symbiotic_api_service_client::SymbioticApiServiceClient,
};
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut relay_client = SymbioticApiServiceClient::new(channel);
 
    let epoch_infos_response = relay_client.get_last_all_committed(tonic::Request::new(GetLastAllCommittedRequest {})).await?;
    let epoch_infos_data = epoch_infos_response.into_inner();
    let mut suggested_epoch = epoch_infos_data.suggested_epoch_info.last_committed_epoch;
 
   let sign_request = tonic::Request::new(SignMessageRequest {
        key_tag: 15, // default key tag - BN254
        message: encode(task_id).into(),
        required_epoch: suggested_epoch,
    });
    let sign_response = relay_client.sign_message(sign_request).await?;
    let sign_data = sign_response.into_inner();
 
    let listen_proofs_request = tonic::Request::new(ListenProofsRequest { start_epoch: suggested_epoch });
    let proofs_stream = relay_client.listen_proofs(listen_proofs_request).await?.into_inner();
    let mut aggregation_proof = None;
    while let Some(proof_response) = proofs_stream.next().await {
        match proof_response {
            Ok(proof_data) => {
                if proof_data.request_id == sign_data.request_id {
                    if let Some(proof) = proof_data.aggregation_proof {
                        aggregation_proof = Some(proof.proof);
                        break;
                    }
                }
            }
            Err(e) => { break; }
        }
    }
 
    appContract.complete_task(task_id, sign_data.epoch, aggregation_proof.unwrap()).await?;
}