Solidity and Contract Interfaces

Smart Contracts

This page replaces the older generic smart-contracts mock with the current Aethelred contract surface: Solidity interfaces for Digital Seals and verified jobs, contract-facing precompile lanes, and the live token, vesting, bridge, and governance contracts in the repository. It is anchored to the current contracts package, whitepaper, tokenomics, and developer docs rather than to placeholder EVM marketing claims.

Solidity ^0.8.20 Oracle + Callback EVM Precompiles Token + Bridge

Open Patterns Developer Precompiles

SOURCE-BACKED AGAINST THE CURRENT CONTRACTS PACKAGE AND PROTOCOL DOCS

Package surface

The current Solidity package is @aethelred/bridge-contracts at version 1.0.0, with TypeScript deployment and test scripts around it.

Verification from contracts

Contracts can submit jobs, receive callbacks, read results, and verify seals through the current oracle and TEE interfaces.

Economic and governance layer

The repo already contains the current token, vesting, bridge, timelock, and stablecoin-routing contracts instead of just interface stubs.

1.0.0Contracts package version

10BAETHEL supply cap

64Bridge ETH confirmations

Current Surface

What the current smart-contract layer actually contains

Aethelred's contract layer is not just a generic Solidity wrapper around a chain. The current repo exposes contract-facing interfaces for verified jobs and seals, plus tokenomics, bridge, and governance contracts with explicit operational constraints.

TEE

Job submission and callbacks

IAethelredTEE exposes payable job submission, fee estimation, lifecycle queries, and callback-target support for completion flows.

SEAL

Oracle and seal reads

IAethelredOracle exposes getResult, getSeal, verifySeal, and output-commitment matching for downstream contracts.

Precompile-aware runtime

The public docs expose 0x0300 for zkML and 0x0400 for TEE flows, while the whitepaper documents seal and tensor lanes beyond those entry points.

GOV

Economic primitives

Token, vesting, bridge, governance timelock, stablecoin routing, reserve automation, and circuit-breaker contracts all exist in the current repository.

Entry Points

The contract-facing surfaces that matter today

Use the interfaces and precompile lanes that are actually documented in the current package and protocol docs. Where a surface is documented in the whitepaper but not yet published as a site-level ABI catalog, this page says so explicitly.

Surface	Current Path	What It Does	Notes
IAethelredTEE	contracts/interfaces/IAethelredTEE.sol	Submit jobs, estimate fees, inspect job status, list requester jobs, and register an optional callback target.	Current Solidity-first path for contract-triggered verified compute.
IAethelredOracle	contracts/interfaces/IAethelredOracle.sol	Read verified results, inspect seals, verify seal status, confirm output commitments, and query model commitments.	Primary trust gate for downstream settlement and automation contracts.
0x0400	TEE precompile lane	Contract-level TEE submission and attestation flows documented on the Developer page.	Use when hardware-backed verification must be triggered directly from Solidity.
0x0300	zkML precompile lane	On-chain proof verification for model execution, exposed in the current zk proof surface.	Matches the current site documentation for contract-level zk verification.
0x0500	Seal verification precompile	Documented in the whitepaper and tokenomics as the contract-facing Digital Seal verification lane.	The public site does not yet publish a full standalone ABI page for this entry point, so prefer the oracle interface where possible.
0x1000-0x10FF	Tensor precompile range	Whitepaper-documented matrix, activation, transformer, quantisation, and verification operations for AI execution.	The current site documents the range, but not a final public ABI-by-ABI catalog.

Practical contract choice:

If you need something copyable today, build first against IAethelredTEE and IAethelredOracle. Use precompile-specific flows only when your contract logic truly depends on direct TEE or zk verification semantics.

Verified Patterns

Copyable Solidity patterns based on the current package layout

The snippets below use the actual import paths and interfaces from the current contracts repository. They are conservative by design: fewer assumptions, real interfaces, and no invented helper packages.

solidity

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.20;

import {IAethelredTEE, IAethelredCallback} from "./interfaces/IAethelredTEE.sol";
import {IAethelredOracle} from "./interfaces/IAethelredOracle.sol";
import {AethelredTypes} from "./types/AethelredTypes.sol";

contract VerifiedJobConsumer is IAethelredCallback {
    IAethelredTEE public immutable tee;
    IAethelredOracle public immutable oracle;

    struct PendingJob {
        address requester;
        bytes32 sealId;
        bool fulfilled;
        bytes result;
    }

    mapping(bytes32 => PendingJob) public jobs;

    error UnknownJob();
    error CallbackOnly();
    error ResultNotReady();
    error SealNotVerified();

    constructor(address teeAddress, address oracleAddress) {
        tee = IAethelredTEE(teeAddress);
        oracle = IAethelredOracle(oracleAddress);
    }

    function requestHybridJob(
        string calldata modelId,
        bytes32 inputCommitment,
        uint64 slaDeadline,
        bytes calldata metadata
    ) external payable returns (bytes32 jobId) {
        AethelredTypes.JobRequest memory request = AethelredTypes.JobRequest({
            modelId: modelId,
            inputCommitment: inputCommitment,
            verificationType: AethelredTypes.VerificationType.Hybrid,
            maxBudget: msg.value,
            slaDeadline: slaDeadline,
            callbackTarget: address(this),
            metadata: metadata
        });

        jobId = tee.submitJob{value: msg.value}(request);
        jobs[jobId].requester = msg.sender;
    }

    function onJobCompleted(
        bytes32 jobId,
        bytes32 sealId,
        bytes32,
        bytes calldata result
    ) external override {
        if (msg.sender != address(oracle)) revert CallbackOnly();

        PendingJob storage job = jobs[jobId];
        if (job.requester == address(0)) revert UnknownJob();

        job.sealId = sealId;
        job.fulfilled = true;
        job.result = result;
    }

    function verifiedResult(bytes32 jobId)
        external
        view
        returns (bytes memory result, bytes32 sealId)
    {
        PendingJob storage job = jobs[jobId];
        if (job.requester == address(0)) revert UnknownJob();
        if (!job.fulfilled) revert ResultNotReady();
        if (!oracle.verifySeal(job.sealId)) revert SealNotVerified();

        return (job.result, job.sealId);
    }
}

solidity

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IAethelredOracle} from "./interfaces/IAethelredOracle.sol";

contract SealGatedEscrow {
    IAethelredOracle public immutable oracle;
    IERC20 public immutable asset;
    address public immutable beneficiary;
    bytes32 public immutable sealId;
    bytes32 public immutable expectedOutputCommitment;
    bool public released;

    error AlreadyReleased();
    error SealNotVerified();
    error OutputMismatch();
    error TransferFailed();

    constructor(
        address oracleAddress,
        address assetAddress,
        address beneficiaryAddress,
        bytes32 sealIdentifier,
        bytes32 outputCommitment
    ) {
        oracle = IAethelredOracle(oracleAddress);
        asset = IERC20(assetAddress);
        beneficiary = beneficiaryAddress;
        sealId = sealIdentifier;
        expectedOutputCommitment = outputCommitment;
    }

    function release(uint256 amount) external {
        if (released) revert AlreadyReleased();
        if (!oracle.verifySeal(sealId)) revert SealNotVerified();
        if (!oracle.verifySealWithOutput(sealId, expectedOutputCommitment)) {
            revert OutputMismatch();
        }

        released = true;
        if (!asset.transfer(beneficiary, amount)) revert TransferFailed();
    }
}

bash

cd contracts
npm install
npx hardhat compile
npx hardhat test
forge test -vvv
npx hardhat run scripts/deploy.ts --network devnet

Contract Catalog

The main contracts currently in the repository

These are the Solidity contracts that define the present economic, governance, and interoperability layer. The descriptions below come from the actual source files and package metadata, not from a generic contract-template narrative.

TOKEN

AethelredToken.sol

Upgradeable ERC-20 with 18 decimals, permit, votes, pause controls, compliance burn, blacklist controls, and bridge authorization.

VEST

AethelredVesting.sol

Role-based vesting engine with nine allocation categories, cliff-plus-linear schedules, milestone support, revocation, and category caps tied to tokenomics.

BRDG

AethelredBridge.sol

Lock-and-mint bridge with relayer consensus, 64 ETH confirmation minimums, a 7 day challenge period, guardian approvals, and a 27 day upgrade timelock floor.

TIME

SovereignGovernanceTimelock.sol

Key-rotation controller built on OpenZeppelin TimelockController with dual Issuer/Foundation consent and a 7 day minimum rotation delay.

USD

InstitutionalStablecoinBridge.sol

Upgradeable testnet stablecoin routing contract with CCTP and TEE issuer-mint flows, proof-of-reserve checks, quotas, circuit breakers, and joint-signature unpause.

SEAL

SealVerifier.sol

Repository bridge-side seal verifier with EIP-712 domain separation, validator signature checks, model registry hooks, and verified output validation.

Workflow

How to work with the current contracts package

The current repository uses a Solidity and TypeScript deployment workflow around Hardhat, with Foundry test coverage available alongside it. The page below sticks to that real toolchain instead of advertising Rust smart-contract authoring that the public contract package does not expose.

Package Metadata

Current package facts

Package@aethelred/bridge-contracts
Version1.0.0
LicenseApache-2.0
Solidity^0.8.20
Node>= 18.0.0

Current Build Path

Compile, test, deploy

Compilenpx hardhat compile
Testsnpx hardhat test
Foundryforge test -vvv
Devnet Deployscripts/deploy.ts --network devnet
Static Checkssolhint and slither

STEP 01

Use the interfaces first

Anchor early contract logic to IAethelredTEE and IAethelredOracle so you do not depend on unpublished ABI details.

STEP 02

Test against current contract tooling

Use Hardhat and Foundry inside the contracts package rather than inventing a separate toolchain or import surface.

STEP 03

Rehearse with sandbox and testnet docs

Pair contract work with the Infinite Sandbox and Testnet pages for current rollout expectations.

STEP 04

Keep addresses overrideable

Do not hardcode final production addresses into docs or app logic while public deployment tables remain unpublished.

Current Boundary

What this page does not claim as of March 12, 2026

The safest contract page is the one that distinguishes current source-backed capability from unresolved publication gaps. This page intentionally stays on that line.

No published mainnet address table

The current contracts README still lists mainnet contract addresses as TBD. This page therefore documents interfaces and behaviors, not final live address maps.

No blanket “fully audited mainnet package” claim

Several individual contracts embed remediated audit annotations, but the package README still labels overall audit status as in progress. This page does not collapse those into one broader claim.

No Rust smart-contract authoring claim

The VM and runtime use Rust, but the public contract authoring path documented here is Solidity plus TypeScript deployment tooling.

No final public ABI catalog for every tensor precompile

The whitepaper documents the tensor precompile range, but this site does not yet publish a final ABI-by-ABI contract reference for the full 0x1000-0x10FF surface.

Start from the real interfaces, then widen only when the docs widen.

For current implementation work, use this page together with the Developer page, the Documentation Hub, the Stablecoin Infrastructure reference, the zk proofs reference, and the Digital Seal reference.

Open Documentation