Build Verifiable AI dApps in Minutes.

// npm install @aethelred/sdk
import { AethelredClient, JobStatus, Network, ProofType } from '@aethelred/sdk';

async function sha256Hex(value) {
  const bytes = new TextEncoder().encode(value);
  const digest = await crypto.subtle.digest('SHA-256', bytes);
  return Array.from(new Uint8Array(digest))
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
}

async function main() {
  const modelHash = '09f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3';
  const client = new AethelredClient({ network: Network.TESTNET });

  const submit = await client.jobs.submit({
    modelHash,
    inputHash: await sha256Hex(JSON.stringify({ prompt: 'Hello AI' })),
    proofType: ProofType.HYBRID,
    priority: 5,
    maxGas: '1000000',
    timeoutBlocks: 120,
    metadata: { source: 'website-home-hero' },
  });

  const job = await client.jobs.waitForCompletion(submit.jobId, {
    pollInterval: 2000,
    timeout: 120000,
  });
  if (job.status !== JobStatus.COMPLETED) {
    throw new Error(`job failed with status=${job.status}`);
  }

  const seals = await client.seals.list();
  const seal = seals.find((item) => item.jobId === job.id);
  if (!seal) {
    throw new Error(`no seal found for job ${job.id}`);
  }

  const verification = await client.seals.verify(seal.id);
  console.log(`seal valid: ${verification.valid}`);
}

main().catch((error) => {
  console.error(error);
});

// Cargo.toml: aethelred-sdk = "1"
use aethelred_sdk::{
    jobs::SubmitJobRequest, AethelredClient, JobStatus, Network, ProofType,
};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AethelredClient::new(Network::Testnet).await?;

    let submit = client
        .jobs()
        .submit(SubmitJobRequest {
            model_hash: "09f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3".into(),
            input_hash: "f4d3a381d89f9f7a35bfa48d9b5f9d7c6c18d2a8b431c1d6a2d2d413c3e7ed09".into(),
            proof_type: Some(ProofType::ProofTypeHybrid),
            priority: Some(5),
            max_gas: Some("1000000".into()),
            timeout_blocks: Some(120),
        })
        .await?;

    let job = client
        .jobs()
        .wait_for_completion(
            &submit.job_id,
            Duration::from_secs(2),
            Duration::from_secs(120),
        )
        .await?;
    if job.status != JobStatus::JobStatusCompleted {
        return Err(format!("job failed with status {:?}", job.status).into());
    }

    let seals = client.seals().list(None).await?;
    let seal = seals
        .into_iter()
        .find(|item| item.job_id == job.id)
        .ok_or_else(|| format!("no seal found for job {}", job.id))?;

    let verification = client.seals().verify(&seal.id).await?;
    println!("seal valid: {}", verification.valid);
    Ok(())
}

package main

import (
    "context"
    "fmt"
    "time"

    "github.com/aethelred/sdk-go/client"
    "github.com/aethelred/sdk-go/jobs"
    "github.com/aethelred/sdk-go/types"
)

func main() {
    ctx := context.Background()

    c, err := client.NewClient(client.Testnet)
    if err != nil {
        panic(err)
    }

    submit, err := c.Jobs.Submit(ctx, jobs.SubmitRequest{
        ModelHash: "09f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3c5d6a1f9f7e2b3",
        InputHash: "f4d3a381d89f9f7a35bfa48d9b5f9d7c6c18d2a8b431c1d6a2d2d413c3e7ed09",
        ProofType: types.ProofTypeHybrid,
        Priority:  5,
        MaxGas:    "1000000",
        TimeoutBlocks: 120,
        Metadata:  map[string]string{"source": "website-home-hero"},
    })
    if err != nil {
        panic(err)
    }
    fmt.Printf("job id: %s\n", submit.JobID)

    job, err := c.Jobs.WaitForCompletion(ctx, submit.JobID, 2*time.Second, 120*time.Second)
    if err != nil {
        panic(err)
    }
    if job.Status != types.JobStatusCompleted {
        panic(fmt.Sprintf("job failed with status %s", job.Status))
    }

    seals, err := c.Seals.List(ctx, nil)
    if err != nil {
        panic(err)
    }

    var sealID string
    for _, seal := range seals {
        if seal.JobID == job.ID {
            sealID = seal.ID
            break
        }
    }
    if sealID == "" {
        panic(fmt.Sprintf("no seal found for job %s", job.ID))
    }

    verification, err := c.Seals.Verify(ctx, sealID)
    if err != nil {
        panic(err)
    }
    fmt.Printf("seal valid: %t\n", verification.Valid)
}