Truebit – Don’t just trust, verify

Truebit API Tasks: Secure, Verifiable Access to Private Data

Truebit — Tue, 06 Jan 2026 21:05:46 +0000

Every system that delegates API access faces the same challenge. A customer service representative needs to process Stripe refunds. An AI agent needs to query an order database. A smart contract needs to pull portfolio valuations from a proprietary financial API. A regulated financial system needs to verify holdings with a custodian. Each operation demands proof of correctness—verification of which endpoint was called, what data was returned, and that execution matched intent. Furthermore, the designated agent may not be trusted to store credentials and/or correctly report API calls. In short, third-party applications require verifiable data and delegated credential management.

Traditional API calls provide opaque results. Partners, auditors, and downstream systems must trust logs, infrastructure and reputation-based claims of data accuracy. On the other hand, API calls made by third-parties involve sharing credentials, coordinating integrations and risk extraneous and unauthorized API access. The first path sacrifices verifiability while the latter sacrifices credibility, security, and simplicity. Neither method offers reproducible results due to API non-determinism. For example, a counter API will return a different response on each call. Crucially, regardless of how calls are handled, non-determinism impairs auditability.

Consider a tokenized, on-chain fund. Its smart contract needs to receive continuous portfolio valuations from the custodian’s API to calculate share prices and process redemptions. Even when the operator fetches the valuation and pushes it onto a blockchain, investors and regulators must trust that a black box infrastructure called the custodian, received a response, and accurately reported it. Alternatively, granting a third-party service access to custodian credentials, introduces integration complexity, exposes sensitive API access, and implicitly assumes trustworthy infrastructure. Neither option provides cryptographic proof that the valuation came from the custodian’s authenticated endpoint at a specific time.

Real World Asset (RWA) applications frequently integrate traditional finance and blockchain data sources. These applications require verifiable third-party calls to private APIs without exposing underlying credentials.

Each scenario involves the same core requirement: cryptographic proof of operational correctness along with privacy for credentials and sensitive data.

Truebit API Tasks delegate API operations within predesignated bounds without exposing credentials. Secrets live encrypted inside a Trusted Execution Environment (TEE), also known as secure enclave, wherein manifest (OpenAPI specifications) constraints limit each credential to its intended use—a Stripe key can only call the refund endpoint, and a custodian API key can only read balances. Guardrails run as restricted code inside the TEE, and unlike external policies, are provably enforceable. Each API execution produces attestation data proving what was called and returned. Coming soon: sensitive portions of attestations can be cryptographically redacted programmatically, for example “greater than $50” replaces “$1,000,000”.

What is an API Task?

An API Task is a declarative definition that wraps an HTTP request with credential isolation and execution attestation. The task manifest follows the OpenAPI standard, specifying the target endpoint, HTTP method, headers, and body template—with placeholders for parameters the caller provides at runtime. Credentials are referenced by key name and resolved at execution time from encrypted storage; they never appear in the manifest itself. Each credential includes a manifest constraint that limits its use to specific endpoints and methods: a Stripe key configured for POST /v1/refunds cannot be used to call /v1/charges, enforced at the TEE level before the request is even constructed.

Creating an API Task involves defining the manifest and uploading credentials via the Truebit CLI—credentials are encrypted client-side before transmission and remain encrypted at rest. Once deployed to a namespace, the task becomes callable at:

https://run.truebit.network/task/api/{namespace}/{task-name}

Callers authenticate with a task authorization token that grants execution rights, not credential access. You can issue tokens to partners, agents, or systems, each scoped to specific tasks and revocable independently.

Execution occurs inside a TEE. The TEE provides point-in-time security: it decrypts credentials, validates parameters, enforces manifest constraints, executes the HTTP request, and returns the response—then retains nothing. It’s a stateless machine that performs actions on behalf of a requestor without persisting any sensitive execution data. Durability comes from the Transcript: a human-readable, cryptographic record that captures what endpoint was called and when, what response was received, and attestation data including enclave measurements and TLS session information. For compliance-sensitive industries, this changes the game. Auditors and third-parties can make private or review auditable API calls without accessing production credentials or sensitive customer data. Auditors need only observe cryptographic Transcripts in order to definitively conclude that systems operated according to specification.

In short: an API Task delivers two guarantees that are usually hard to achieve together.

Credential isolation—partners, internal systems, AI agents, or smart contracts can trigger operations without gaining visibility into the underlying credentials or how they’re stored.
Verifiable execution—every call produces a Transcript with cryptographic attestation proving exactly what API endpoint was called and when, the data that was returned, and that the operation executed precisely as defined. This allows you to delegate API access without sharing secrets and prove exactly what happened without relying on self-reported logs.

The TEE guarantees secure execution; the Transcript proves it happened.

Creating an API Task

Creating an API task involves two main steps:

Create an OpenAPI manifest:
- This manifest describes the accessible endpoints, data formats, validation rules, and any caller restrictions.
- If the API requires authentication, you also need to securely upload locally encrypted credentials to the Truebit Verify API endpoint.
- The manifest schema is used by Truebit Verify to validate all calls before executing network requests. Tools like Swagger Editor can help build or modify an existing schema provided by the API publisher.
Deploy the task:
- Before deploying, use the Truebit CLI command start-api to directly call the API server from your Terminal and verify that the task functions correctly with the target API.
- Once the manifest is ready, instantiate the task within Truebit Verify using the Truebit CLI command create-api with your manifest as the input.
- If the API requires authentication, you must securely deploy the credentials using the api-auth command. These credentials are then stored encrypted at rest on Truebit Verify.
Use the task:
- Call the task using the Task Execution Endpoint.
- You may optionally define specific permissions regarding who is allowed to execute the task.
- Upon execution, the system returns an API call result and generates a verifiable Transcript.

Understanding the Transcript

Truebit’s core innovation lies in its ability to bridge the gap between the inherently non-deterministic “outside” world and the rigorous, deterministic environment required by blockchain technology and high-assurance industries. By design, blockchains demand absolute certainty and verifiable execution; however, interfacing with external APIs, legacy systems, or complex off-chain computations introduces potential points of failure and non-determinism. Truebit resolves this fundamental tension by establishing a durable, cryptographically-secure attestation of correctness for operations that occur off-chain.

The mechanism by which Truebit achieves this level of assurance is through the generation of a Transcript. This Transcript is not merely a log; it is a meticulous, cryptographic record of everything that occurred during the execution of an off-chain API call or compute task. This comprehensive, step-by-step documentation transforms a non-deterministic interaction into a sequence of verifiable steps.

Crucially, this system dramatically changes the paradigm of reproducibility and verification. Instead of relying on the cumbersome, resource-intensive, and potentially inconsistent method of re-executing the entire task—which would require calling the external source again and risking a different result—Truebit achieves reproducibility by verifying the Transcript itself. Specialized verification algorithms mathematically prove the integrity and correctness of the deterministic operation based on the submitted Transcript. If the Transcript holds up to this mathematical proof, it confirms, beyond a shadow of a doubt and with rigorous certainty, that the original execution was performed exactly as intended and without error, all while eliminating the need to ever trust or call the external, non-deterministic source again for validation.

Detailed information about this process is available in Truebit’s Documentation portal: How to create API tasks. If you would like to try it, we have developed a demo site where it is possible to call an API Task and inspect its certificates here: https://demo.truebit.network/.

The post Truebit API Tasks: Secure, Verifiable Access to Private Data first appeared on Truebit - Don’t just trust, verify.

The Bridge to Everything: Truebit Dynamic Oracles Power Seamless Code and API Calls from Smart Contracts to any Blockchain – Part I

Truebit — Wed, 03 Dec 2025 20:23:48 +0000

Your smart contract just hit a wall. It needs real-time compliance data, cross-chain datafeeds, data from the web, or to execute arbitrary code—but it’s trapped in the blockchain’s walled garden.

What if your contract could just execute arbitrary JavaScript, call any API, and return cryptographically verified results—all without pre-deploying oracle infrastructure?

Introducing Truebit’s Dynamic Oracles: simply include code and API calls in your transaction, trigger offchain execution, and receive verified results back on-chain—all with zero upfront infrastructure.

In this guide, you’ll build and experience a complete Dynamic Oracle—from custom JavaScript logic to verified on-chain callbacks.

The Oracle Problem: Opacity, Friction, and Limited Auditability

Blockchain smart contracts face a fundamental limitation: they cannot natively execute computational tasks beyond the EVM’s deterministic operations or fetch external data.

Existing oracle solutions address data retrieval but create new problems:

Opacity of Computation: Traditional oracles only attest to final results, not the process itself, leaving users to trust black-box operations without visibility into how data was processed.

Deployment Friction: Existing systems require pre-registration and deployment of both computational logic and oracle infrastructure before any smart contract can use them, creating significant overhead.

Limited Auditability: When oracles lack a verifiable data processing record, one cannot retroactively verify whether results were computed correctly, making dispute resolution impossible.

Siloed interactions: Static oracles lack data flows to or from other blockchains. They cannot query cross-chain state or return verified results to multiple destination chains simultaneously.

These restrictions are particularly problematic for regulated applications like Real World Asset (RWA) tokenization and compliance verification, where auditability and provenance are mandatory.

Truebit Dynamic Oracles (in beta) eliminate these tradeoffs by providing an on-demand oracle system with full execution transparency and cryptographic verification.

Dynamic Oracles: Zero-Friction Verifiable Data & Computation for Smart Contracts

Dynamic Oracles are smart contract interactions that enable blockchain transactions to trigger arbitrary offchain computation and data retrieval with cryptographic verification.

Flexible data processing: Your contract executes JavaScript or TypeScript code, API calls, and cross-chain queries—all specified at transaction time, not deployment time.

Auditable execution: Each step generates cryptographic proof of correctness with code swiftly executed by offchain nodes participating in interactive verification games.

Cross-chain return results: Dynamic oracles callback results to smart contracts on any blockchain where Truebit’s WatchTower contracts exist.

For developers, this paradigm shift translates directly into massive productivity gains and a significantly improved user experience.

Quick Start: Your First Dynamic Oracle Contract

Let’s build a simple contract that demonstrates the core pattern; we’ll request offchain computation and handle verified results.

Step 1: Understand the architecture

Dynamic Oracles uses a “WatchTower” contract to bridge requests and responses to and from Truebit Verify.

Step 2: Write Javascript Logic

Let’s write a simple Fibonacci function for demonstration purposes. This is the code we want to execute offchain:

function main(n) {
    // Handle base case
    if (n <= 1) return n;
    
    // Iterative computation to avoid stack overflow
    let a = 0, b = 1;
    for (let i = 2; i <= n; i++) {
        let temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

// Print the result for an embedded JS function execution to be retrieved in the callback
console.log(main(parseInt(Input)));

The reserve word Input logged and sent to the main function in the code above represents the value sent from the smart contract to the offchain JavaScript execution environment.

Step 3: Create your User Contract (The “FibonacciCalculator” Contract)

Your smart contract can integrate both Solidity and JavaScript. The JS code is sent to Truebit Verify as a string, and results come back through a callback function.

FibonacciCalculator.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Enum for Dynamic Oracle execution types
library DOTypes {
    enum ExecutionType {
        EMBEDDED_FUNCTION
    }
}

// WatchTower Interface used to request execution
interface IWatchTower {
    function requestExecution(
        string calldata methodSignature,
        bytes calldata input,
        bytes32 codeHash,
        DOTypes.ExecutionType executionType
    ) external returns (uint256);
}

/**
 * @title FibonacciCalculator
 * @notice Fibonacci numbers off-chain using Truebit's Dynamic Oracles
 * @dev Shows the basic pattern: store code, trigger execution, handle callback
 */
contract FibonacciCalculator {
    // Immutable WatchTower contract reference
    IWatchTower public immutable watchTower;
    
    // State variables to check last execution result
    uint256 public lastWTExecutionId;
    uint256 public lastResult;
    
    // Custom errors
    error NotwatchTower(address sender);
    
    // Events for tracking computation lifecycle
    event FibonacciRequested(
        uint256 wtExecutionId,
        address indexed requester,
        uint256 n,
        uint256 timestamp
    );
    
    event FibonacciComputed(
        address indexed requester,
        uint256 result,
        string[] transcripts,
        uint256 wtExecutionId,
        uint8 status,
        string _callbackMessageDetails,
        uint256 timestamp
    );
    
    // Ensure we only get callbacks from the WatchTower contract
    modifier onlywatchTower() {
        if (msg.sender != address(watchTower)) {
            revert NotwatchTower(msg.sender);
        }
        _;
    }
    
    /**
     * @notice Constructor - initializes with WatchTower
     * @param watchTowerAddress Address of the Truebit WatchTower contract
     */
    constructor(address watchTowerAddress) {
        watchTower = IWatchTower(watchTowerAddress);
    }
    
    /**
     * @notice Returns the WatchTower contract address
     * @return Address of the WatchTower
     */
    function getWatchTowerAddress() external view returns (address) {
        return address(watchTower);
    }
    
    /**
     * @notice Returns the last execution result
     * @return wtExecutionId The WatchTower execution ID
     * @return result The computed Fibonacci result
     */
    function getLastExecutionResult() external view returns (uint256 wtExecutionId, uint256 result) {
        return (
            lastWTExecutionId,
            lastResult
        );
    }
    
    /**
     * @notice Returns the JavaScript code for Fibonacci computation
     * @dev This is a helper function to keep code organized
     * @return JavaScript function as a string
     */
    function getTaskSource() public pure returns (string memory) {
        return string(abi.encodePacked(
            "function main(n) { ",
            "    if (n <= 1) return n; ",
            "    let a = 0, b = 1; ",
            "    for (let i = 2; i <= n; i++) { ",
            "        let temp = a + b; ",
            "        a = b; ",
            "        b = temp; ",
            "    } ",
            "    return b; ",
            "}",
            "console.log(main(parseInt(Input)));"
        ));
    }
    
    /**
     * @notice Request Fibonacci computation for a given n
     * @dev This function triggers off-chain execution via WatchTower
     * @param n The Fibonacci number to compute (F(n))
     */
    function requestFibonacci(uint256 n) external {
        require(n < 100, "n too large - choose n < 100");
        
        bytes32 codehash = keccak256(bytes(getTaskSource()));
        bytes memory payload = abi.encode(n);
        
        uint256 id = watchTower.requestExecution(
            string(abi.encodePacked("fibonacci(uint256)")),
            payload,
            codehash,
            DOTypes.ExecutionType.EMBEDDED_FUNCTION
        );
        
        lastWTExecutionId = id;
        emit FibonacciRequested(id, msg.sender, n, block.timestamp);
    }
    
    // At this point:
    // 1. WatchTower detects the execution request
    // 2. Truebit platform fetches the code to execute within the codehash
    // 3. Off-chain nodes execute the JavaScript with input 'n'
    // 4. Results are verified through interactive verification games
    // 5. WatchTower calls back to callbackTask() with verified result
    
    /**
     * @notice Callback function invoked by WatchTower with verified result
     * @dev Only callable by WatchTower (enforced by onlywatchTower modifier)
     * @param resultData ABI-encoded result from off-chain computation
     * @param transcripts Array of transcripts from execution
     * @param wtExecutionId The WatchTower execution ID
     * @param status Status code (0 == success, 1 == error, 2 == exceeded)
     * @param _callbackMessageDetails Additional details about the callback
     */
    function callbackTask(
        bytes calldata resultData,
        string[] memory transcripts,
        uint256 wtExecutionId,
        uint8 status,
        string memory _callbackMessageDetails
    ) external onlywatchTower {
        uint256 result;
        
        if (status == 0) {
            result = abi.decode(resultData, (uint256));
        } else {
            result = 0;
        }
        
        lastResult = result;
        
        emit FibonacciComputed(
            msg.sender,
            result,
            transcripts,
            wtExecutionId,
            status,
            _callbackMessageDetails,
            block.timestamp
        );
    }
}

Let’s unpack the code above: when your smart contract calls requestFibonacci(n), it triggers offchain execution via the WatchTower contract.

Step 4: Deployment

Your contract’s callback function will get called with verified results and a reference to the task’s execution ID.

Let’s deploy and test this contract; we are using Hardhat for testing and deployment, but you can use any framework.

Let’s install Hardhat and configure it (in this example we use Hardhat V2), then we can create a deployment script:

npm init -y
npm pkg set type="commonjs"
npm install --save-dev hardhat@^2.19.0 @nomicfoundation/hardhat-toolbox@^4.0.0

# IMPORTANT: This is a necessary folder to contain the contract(s) to be deployed
mkdir -p contracts

You need to set up a provider (we use Alchemy but any provider will work). Make sure to replace the private key placeholder with your actual private key.

hardhat.config.js

require("@nomicfoundation/hardhat-toolbox");

module.exports = {
    solidity: "0.8.24",
    networks: {
        "mainnet": {
            url: "https://api.avax.network/ext/bc/C/rpc",
            chainId: 43114,
            accounts: [""]
        }
    }
};

deploy.js

const { ethers } = require("hardhat");
const fs = require("node:fs");
const path = require("node:path");

async function main() {
    const network = await ethers.provider.getNetwork();
    console.log(`Deploying to network: ${network.name} (chainId: ${network.chainId})`);
    
    // Truebit Watchtower Address for DO execution
    const WATCHTOWER_ADDRESS = '0xEAd039cA35B9c6592B638C0C4E2b7f42F078B754';
    
    console.log("Deploying FibonacciCalculator contract...");
    
    const [deployer] = await ethers.getSigners();
    console.log(`Deploying with account: ${deployer.address}`);
    
    const FibonacciCalculator = await ethers.getContractFactory("FibonacciCalculator");
    const fibonacciCalculator = await FibonacciCalculator.deploy(WATCHTOWER_ADDRESS);
    
    await fibonacciCalculator.waitForDeployment();
    const contractAddress = await fibonacciCalculator.getAddress();
    
    console.log("FibonacciCalculator deployed to:", contractAddress);
    
    // Save the address to a config file
    const config = {
        contractAddress: contractAddress,
        watchTowerAddress: WATCHTOWER_ADDRESS,
        deployerAddress: deployer.address,
        deployedAt: new Date().toISOString()
    };
    
    fs.writeFileSync(
        path.join(__dirname, `${network.name}-contract-config.json`),
        JSON.stringify(config, null, 2)
    );
    
    console.log(`Contract address information saved in: ${network.name}-contract-config.json`);
    return contractAddress;
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

Step 5: Try it!

requestFibonacci.js

const { ethers } = require("hardhat");
const fs = require('node:fs');
const path = require('node:path');

async function main() {
    // Request Fibonacci computation for n=10 for example
    const n = 10;
    let contractAddress;
    
    try {
        const network = await ethers.provider.getNetwork();
        console.log(`Executing in network: ${network.name} (chainId: ${network.chainId})`);
        
        // Load contract address from config
        const configPath = path.join(__dirname, `${network.name}-contract-config.json`);
        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
        contractAddress = config.contractAddress;
        
        console.log("Using contract address from config:", contractAddress);
        
        // Load contract ABI
        const abiPath = path.join(__dirname, './artifacts/contracts/FibonacciCalculator.sol/FibonacciCalculator.json');
        const artifactData = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
        
        const [signer] = await ethers.getSigners();
        const contract = new ethers.Contract(contractAddress, artifactData.abi, signer);
        
        console.log(`Using signer: ${signer.address}`);
        console.log(`Requesting Fibonacci computation for n=${n}...\n`);
        
        const tx = await contract.requestFibonacci(n);
        console.log(`Transaction hash: ${tx.hash}`);
        
        const receipt = await tx.wait();
        console.log(`\nTransaction confirmed in block ${receipt.blockNumber}`);
        console.log(`Gas used: ${receipt.gasUsed.toString()}`);
        console.log(`Status: ${receipt.status === 1 ? 'Success' : 'Failed'}`);
    } catch (error) {
        console.error("Error requesting Fibonacci:");
        console.error(error.message);
        if (error.message.includes("contract-config.json")) {
            console.error("\nPlease deploy the contract first:");
            console.error("npx hardhat run deploy.js");
        }
        process.exitCode = 1;
    }
}

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

getLastExecution.js

const { ethers } = require("hardhat");
const fs = require('node:fs');
const path = require('node:path');

async function main() {
    try {
        const network = await ethers.provider.getNetwork();
        console.log(`Executing in network: ${network.name} (chainId: ${network.chainId})`);
        console.log("Fetching Fibonacci last results...\n");
        
        const configPath = path.join(__dirname, `${network.name}-contract-config.json`);
        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
        const contractAddress = config.contractAddress;
        
        console.log(`Using contract address: ${contractAddress}\n`);
        
        const abiPath = path.join(__dirname, './artifacts/contracts/FibonacciCalculator.sol/FibonacciCalculator.json');
        const artifactData = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
        
        const provider = ethers.provider;
        const contract = new ethers.Contract(contractAddress, artifactData.abi, provider);
        
        console.log("Calling last result saved...\n");
        const lastResult = await contract.getLastExecutionResult();
        
        console.log("=== Fibonacci Task Last Execution ===\n");
        console.log(`WatchTowerExecutionId: ${lastResult.wtExecutionId}`);
        console.log(`Result: ${lastResult.result}\n`);
    } catch (error) {
        console.error("Error fetching last results:");
        console.error(error.message);
        if (error.message.includes("contract-config.json")) {
            console.error("\nPlease deploy the contract first:");
            console.error("npx hardhat run deploy.js --network \n");
        }
        process.exitCode = 1;
    }
}

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

Project preview

Hardhat command execution

# Deploy the testing contract with the specified network
npx hardhat run deploy.js --network mainnet

# Generate a request for fibonacci execution through DO and Truebit platform
npx hardhat run requestFibonacci.js --network mainnet

# Get the last execution after execution through DO and Truebit platform
npx hardhat run getLastExecution.js --network mainnet

Ready to Get Started?

Dynamic Oracles are available in beta on Truebit Verify for Avalanche and Ethereum. Contact us at [email protected]

→ View developer documentation

→ Talk to an expert

In Part II we will show you how to use Dynamic Oracles to do cross-chain calls and create an effective bridge for cross-chain compliance verification.

The post The Bridge to Everything: Truebit Dynamic Oracles Power Seamless Code and API Calls from Smart Contracts to any Blockchain – Part I first appeared on Truebit - Don’t just trust, verify.

Truebit Announces General Availability of Verify Platform: The Verification Layer for Tokenized Assets

Truebit — Tue, 18 Nov 2025 05:15:59 +0000

Cryptographic proof for any offchain operation, enabling developers to build and launch verified applications in minutes

New York — November 18, 2025 — Truebit today announced general availability of Truebit Verify, the verification layer for tokenized assets. The platform generates interactive and cryptographic proof for any offchain operation—API calls, complex calculations, compliance workflows, and cross-chain orchestration—enabling developers to build and launch verifiable applications in minutes instead of months.

While blockchains provide transparency for on-chain transactions, the critical operations that determine asset value happen offchain: reserve verification, NAV calculations, compliance checks, custody tracking, and risk models. These processes operate as black boxes without cryptographic proof, creating a trust gap that discounts asset values and limits institutional adoption.

“Blockchain adoption is constrained by the ‘just trust us’ problem for offchain operations,” said Jason Teutsch, Founder of Truebit. “Investors discount asset values when they can’t verify reserves. Regulators require proof that compliance policies execute correctly. Counterparties won’t trust AI agents without demonstrated risk parameter adherence. Truebit Verify solves this by generating cryptographic proof for any offchain computation — proving what code ran, what data was used, and what the results were.”

Platform Capabilities

Truebit Verify provides infrastructure for building verifiable systems through core capabilities:

Trustless Compute – Execute complex calculations, risk models, and AI inference offchain while maintaining cryptographic proof of correctness. Powers portfolio optimization, derivatives pricing, and algorithmic decision-making with provable execution.

Certified Transcripts – Every operation generates an immutable audit trail documenting inputs, code hash, execution events, and outputs. These transcripts are cryptographically signed and timestamped for auditors, regulators, and counterparties.

Verified API Integration – Connect to external and confidential data sources with tamper-proof records proving when data was retrieved, from which source, and with what parameters. Enables proof of reserves, custody verification, and authenticated data feeds for critical business operations.

Compliance Orchestration – Automate multi-step regulatory workflows with policy enforcement at the smart contract level with complete audit trails. Bake directly into ERC-3643 token contracts and vault auditable KYC/AML, accreditation checks, NAV, proof of reserves, and other transfer restrictions.

Dynamic Oracles – Enable smart contracts to programatically access any API and execute arbitrary logic on-demand. Smart contracts specify data sources and computation in transactions; Truebit nodes execute offchain and return verified results with immutable execution records.

Cross-Chain Operations – Move data and enforce policies across multiple blockchains while maintaining verification integrity. Enables multi-chain asset management, cross-border compliance, and chain-agnostic applications.

Solutions Built on Truebit Verify

The general availability release reflects maturity gained through production deployments:

Verified Compliance for Digital Assets

Truebit powers compliance engines that enforce regulatory requirements at the smart contract level for stablecoins, tokenized securities, real world and digital asset platforms. The solution includes rapid ERC-3643 token deployment, automated KYC/AML verification, dual-track regulatory structures (US Reg D + Global Reg S), and real-time audit trail generation.

CHAYNE, an early adopter, uses Truebit Verify to provide verifiable execution of compliance workflows and regulatory reporting for digital asset operations.

“Regulators and LPs don’t accept ‘trust us.’ They need proof. Truebit’s certified transcripts give us an immutable audit trail for every compliance decision—showing exactly what data was checked, when, and which policy was applied. There’s a big difference between claiming compliance and proving it, which is why we’re integrating Truebit Verify into our compliance infrastructure to bring this level of transparency to institutional funds,” said Travis John, Managing Partner at CHAYNE, a financial technology firm delivering on-chain efficiency and transparency to traditional markets.

DeFi Verification for Tokenized Assets

Tokenization platforms use Truebit Verify to prove reserves, verify valuations, and document asset lifecycles. The platform enables real-time proof of reserves, automated NAV calculations, custody tracking, and asset lifecycle documentation from origination through disposition — addressing the trust gap that causes investors to discount tokenized asset values.

Developer Tools and Infrastructure

Truebit Verify provides:

Multi-language support – TypeScript, JavaScript, Python, Rust, C++ via WebAssembly, and more
API Task framework – Integrate external services with proof of interaction
Function Tasks – Execute custom business logic with verified results
Orchestration layer – Visual workflow builder for complex processes
Transcript API – Programmatic access to execution proofs

General Availability

Truebit Verify is available immediately. You can learn more at www.truebit.io or contact us to speak to one of our experts. Developer documentation and implementation guides are available at devs.truebit.io.

About Truebit

Truebit provides verification infrastructure for tokenized assets, ensuring the integrity and auditability of offchain processes. By making offchain computations transparent and provable, Truebit enables compliant solutions for digital asset tokenization, verifiable AI, transparent supply chains, and decentralized finance.

Contact:
[email protected]

The post Truebit Announces General Availability of Verify Platform: The Verification Layer for Tokenized Assets first appeared on Truebit - Don’t just trust, verify.

Truebit Founder Receives ACM CCS Test-of-Time Award

Truebit — Wed, 15 Oct 2025 18:54:40 +0000

Truebit’s founder, Jason Teutsch has received the ACM CCS Test-of-Time Award for his 2015 paper, “Demystifying Incentives in the Consensus Computer” coauthored with Loi Luu, Raghav Kulkarni, and Prateek Saxena. This award recognizes research that has had a lasting impact on computer and communications security.

As the first academic work about Ethereum, this work challenged Satoshi Nakamoto’s gospel assumption that all nodes in a network are honest, instead arguing that nodes are rational and may lack the incentive to verify blocks they didn’t create. This phenomenon is colloquially known as the “verifier’s dilemma.”

This work laid the groundwork for the verification game method for blockchains, subsequently introduced by Teutsch and Reitwießner, which today underlies all optimistic roll-ups. The paper reviews initially included a “strong reject,” however, a Bitcoin fork in July 2015, demonstrating the practicality of the verification issues addressed in the paper, swayed the reviewers to accept the work.

Teutsch’s work with Truebit applies this verification technology to real-world applications such as machine learning, supply chains, and real-world assets. The award recognizes the enduring influence of his research on the field of blockchain and decentralized systems.

Listen to Jason’s acceptance speech here.

The post Truebit Founder Receives ACM CCS Test-of-Time Award first appeared on Truebit - Don’t just trust, verify.

The AI Accountability Gap: Why Verification Is No Longer Optional

Truebit — Mon, 13 Oct 2025 18:16:56 +0000

The biggest myth in AI is that ‘black box’ opacity is an unavoidable trade-off for power. For critical systems, this trade-off is no longer acceptable—and it’s a problem we’ve already solved.

As artificial intelligence increasingly powers critical systems – from automated trading platforms to cross-border compliance checking to real-world asset valuation – the inability to audit, verify, or even explain AI decision-making has become a fundamental business risk.

The problem is straightforward: AI systems operate as black boxes. You get outputs, but the computational process that generated them remains opaque. For consumer applications, this might be merely frustrating. For financial infrastructure, supply chain operations, or regulatory compliance, it’s unacceptable.

The Trust Crisis Is Already Here

Consider three scenarios where AI verification is a present-day requirement:

AI-Powered Financial Trading

Deep3’s AI trading platform analyzes on-chain data to provide personalized trading recommendations. As the platform evolves toward autonomous trading, a fundamental challenge emerges: when AI directly controls users’ wallets and makes financial decisions, how do you build trust?

“When we move into the realm of not only our code managing your money, but an AI that we’ve built managing your money on top of that, there’s so many elements of that stack that need an extra level of transparency and verifiability to gain user confidence,” explains Daniel Stephens, Deep3’s founder.

The platform needs to prove that AI respects user-defined risk parameters, that trading decisions follow prescribed logic, and that no manipulation occurs between analysis and execution. Without verification, users must simply trust that the black box AI is acting in their best interest. Read the full Deep3 case study →

Global Trade and Tariff Compliance

When tariffs range from 10% to over 50% depending on country of origin, accurately calculating duties becomes both critical and complex. AI can analyze tariff codes and regulatory changes in real time, but as Jason Teutsch, Truebit’s founder, points out: “Companies need proof that the AI’s calculations themselves are trustworthy. Like a notary for computational processes, verification technology can create proof that an AI system correctly applied the correct tariff rates and pulled data from legitimate sources—something customs authorities are increasingly demanding.”

Blockchain can track a product’s journey across borders. AI can calculate applicable tariffs. But neither proves the calculations were performed correctly. That verification gap becomes a multi-billion dollar problem when goods are detained, duties are disputed, or audits reveal discrepancies.

Read our CoinTelegraph coverage on how Trade Wars Could Spur Governments to Embrace Web3 →

Looking for an overview of the benefits of verified tax compliance? Read David Deputy’s RegTech article for more →.

Automated Asset Valuation and Compliance

The tokenization of real-world assets, projected to become a $2-4 trillion market by 2030, depends heavily on decentralized AI and automation. Asset valuation models must process complex data from multiple sources. Compliance checks must verify investor eligibility across jurisdictions. Risk models must continuously monitor collateralization ratios.

Each of these processes involves AI making consequential decisions about asset values, trades, and regulatory compliance. When a tokenized private credit fund uses AI to calculate Net Asset Value, or when an automated compliance engine determines investor eligibility, stakeholders need incontrovertible proof that AI operated within prescribed parameters or bounds.

Traditional solutions rely on manual audits and centralized trust. Neither scales when assets settle in seconds and operate across borders. Read more about verification challenges in RWA tokenization →

What AI Verification Actually Means

Verification transforms AI from a trust-based system to a proof-based system. Instead of “trust our AI,” it enables “audit our AI’s execution.”

This happens through three critical capabilities:

Verifiable Execution: Cryptographic proof that specific code ran on specific inputs, producing specific outputs without alteration or manipulation. Every AI inference, every data transformation, every decision point becomes independently auditable.

Auditable Decision Trails: Immutable records of prompts, computational processes, and inferences. When AI makes a decision, verification creates a tamper-proof record of exactly how that decision was reached.

Data Provenance: Tracing the origin and lineage of training data and inference inputs. This prevents data poisoning, confirms data authenticity, and proves which external sources were consulted.

The technical implementation varies from interactive proofs to zero-knowledge systems to trusted execution environments, but the outcome remains consistent: moving from “trust me” to “verify this.”

Bridging the Gap Between AI and Accountability

The convergence of AI with blockchain-based systems creates unique verification challenges. Blockchains are deterministic by design – the same input always produces the same output. AI models, particularly large language models, can introduce non-determinism for creativity and adaptability.

Rather than trying to make AI deterministic, verification focuses on critical checkpoints: proving which model version ran, which prompts were used, which external data was accessed, and that safety guardrails were respected. You verify the boundaries and constraints, even when the specific output varies.

This approach enables AI systems to maintain their adaptive capabilities while providing the accountability that financial systems, regulatory frameworks, and business operations require.

Learn more about how verification works with AI systems →

Why This Matters Now

AI adoption in critical infrastructure is accelerating faster than governance frameworks can adapt. According to recent analysis, blockchain and Web3 technologies are emerging as potential solutions to AI’s transparency problem, precisely because they introduce verifiable computation into AI workflows.

As one industry observer notes: “In a world where we can no longer trust what we see with our own eyes, verification provides the certainty we need in critical systems.” This becomes especially urgent as AI moves from recommendation engines to autonomous decision-makers, from suggesting trades to executing them, from identifying compliance risks to enforcing compliance rules, from estimating asset values to determining them.

The organizations building AI-powered financial infrastructure today are discovering that verification is foundational infrastructure. Without it, they face three unacceptable choices: limit AI capabilities to maintain trust, accept opacity and hope for the best, or build extensive custom verification systems themselves.

Verification technology offers a fourth path: AI systems that are both powerful and provable. Systems where stakeholders don’t need to trust the AI – they can verify it.

Learn more about Truebit Verified AI →

The post The AI Accountability Gap: Why Verification Is No Longer Optional first appeared on Truebit - Don’t just trust, verify.

Beyond ‘Trust Us’: Verification is the Catalyst for High-Value Digital Assets

Truebit — Sun, 28 Sep 2025 23:29:40 +0000

The capital markets are clear about what they want from digital assets: the efficiency and liquidity of blockchain technology with the transparency and compliance standards they’re accustomed to in traditional finance. What’s holding back the flood of institutional investment isn’t regulatory uncertainty but the lack of continuous, verifiable proof that digital assets represent what they claim.

While established players like BlackRock and JPMorgan can leverage their reputation to enter the tokenization market, the rest of the market faces a different reality. For them, “trust us” isn’t enough to attract sophisticated investors or satisfy regulators who demand proof, not promises.

The Trust Tax in Digital Asset Management

Traditional asset management relies on periodic audits, quarterly reports, and reputational trust to assure investors that their capital is properly managed. This model worked when assets were held in traditional custody arrangements and transactions settled over days.

But digital assets promise something different: real-time liquidity, 24/7 markets, and global accessibility. These benefits become liabilities when the underlying verification systems can’t keep pace. Between audit cycles, investors face fundamental questions they can’t answer: Are backing assets still in place? Have risk parameters been exceeded? Are compliance requirements being met?

The gap between digital asset promises and traditional verification methods creates a “trust tax”, or a risk discount that investors apply to any digital asset that can’t prove its operations in real-time.

What Investors Actually Want

Investors evaluating digital assets need capabilities that go far beyond traditional periodic reporting:

Operational Transparency: Investors need real-time visibility into asset backing, not quarterly snapshots that leave months of uncertainty.
Regulatory Compliance: Compliance teams need auditable proof that KYC, AML, and investment mandate requirements are continuously met, not just periodically checked.
Risk Management: Portfolio managers need continuous confirmation that leverage limits, concentration restrictions, and other risk parameters are being respected.
Custody Verification: Investors need ongoing proof that assets have not been rehypothecated, moved, or encumbered without authorization.

These requirements go far beyond what traditional periodic audits can provide. They demand a new infrastructure that can generate continuous, cryptographic proof of operational integrity.

The Economics of Continuous Verification: Verified Assets = Higher Value

The impact of moving from periodic to continuous verification goes beyond just operational to economical. Assets that can prove their integrity in real-time command higher valuations because they carry lower risk premiums. They achieve better liquidity because investors have confidence to trade without waiting for the next audit cycle. And they scale more efficiently because verification processes are automated rather than manual.

Take proof of reserves as an example. A traditional approach might involve quarterly attestations from a certified public accountant, leaving investors with months of uncertainty about whether backing assets have been moved or pledged elsewhere. Continuous verification can provide real-time confirmation that reserves exist and haven’t been encumbered, eliminating the uncertainty premium that investors apply during inter-audit periods.

Verifiable Digital Assets

The path forward requires rethinking how asset managers approach transparency. Instead of periodic reporting supplemented by reputation, digital assets need verification built into their operational infrastructure to unlock the trillion dollar market opportunity.

This means creating systems where:

Asset valuations are updated and verified in real-time using auditable data sources
Custody arrangements are continuously monitored and reported
Compliance checks are automated and generate tamper-proof audit trails
Risk parameters are enforced programmatically with verifiable execution

For asset managers, this represents an opportunity to compete on proof rather than reputation. For investors, it provides the transparency and risk management they need to allocate significant capital to digital assets.

The Competitive Advantage of Early Adoption

Asset managers who implement verification early will capture the institutional capital currently sitting on the sidelines. As regulatory frameworks solidify around verifiable operational standards, those who can demonstrate verified compliance will have a significant advantage over those still relying on periodic attestations and reputational trust.

The question is whether asset managers will recognize the competitive advantage it provides and implement it before their competitors do.

Ready to explore how verification can differentiate your digital assets and help you compete with the largest players in the market? Get in touch with our experts to learn more.

The post Beyond ‘Trust Us’: Verification is the Catalyst for High-Value Digital Assets first appeared on Truebit - Don’t just trust, verify.

Unlocking the Trillion-Dollar Tokenization Opportunity: Why Compliance is a Verification Problem

Truebit — Mon, 15 Sep 2025 04:31:57 +0000

The trillion-dollar tokenization market has a compliance problem. When complex eligibility decisions involve multiple data sources and jurisdictions, ‘trust us’ documentation isn’t enough—regulators need proof the algorithms actually work as intended.

Consider a tokenized fund screening investors across multiple jurisdictions. Traditional systems can log that ‘Rule X was applied to Investor Y’ but they can’t prove the rule logic executed correctly, wasn’t tampered with, or properly handled conflicts between different regulatory frameworks.

As financial assets move on-chain and compliance becomes algorithmic, regulators and institutional investors need mathematical proof that compliance decisions were computed correctly, not just documented

The Convergence Creating Urgency

Powerful market forces are converging, making this challenge urgent.

Institutional adoption is accelerating. Major asset managers like BlackRock, Franklin Templeton, and JPMorgan are deploying tokenized funds that require embedded KYC/AML and jurisdictional controls at the smart contract level.
Regulatory frameworks are tightening. Stablecoins have surpassed $230 billion in market cap, with new laws imposing licensing requirements that demand automated, auditable compliance.
Cross-border complexity is intensifying. Compliance requirements vary dramatically across jurisdictions while traditional KYC vendors remain offchain and incompatible with smart contract execution.
Technical enforcement is becoming mandatory. Governments are increasingly requiring compliance to be embedded in code rather than relying on legal documentation alone.

The result: institutional capital that demands compliance certainty, regulatory frameworks that require technical enforcement, and infrastructure that wasn’t built for either.

When ‘Trust Us’ Isn’t Enough

Having compliance rules isn’t enough—you need to prove they work as intended. Take the multi-jurisdictional fund mentioned earlier: traditional systems can document the decision but can’t demonstrate that the eligibility algorithm processed all relevant data, applied rules correctly, and reached the right conclusion when jurisdictional requirements conflicted.

The complexity compounds when algorithms make these decisions autonomously. When an algorithm calculates that an investor’s combined holdings across multiple funds would exceed regulatory limits, traditional systems can only show the final “rejected” decision. They can’t demonstrate that the algorithm correctly aggregated holdings across platforms, applied the right regulatory thresholds for each jurisdiction, and handled currency conversions properly, step by step.

Complex compliance decisions involve algorithms – risk scoring, eligibility calculations, cross-jurisdictional rule reconciliation. These computations must be auditable not just in their inputs and outputs, but in their execution. Digital signatures can prove who made a decision and that it wasn’t tampered with, but they can’t prove the decision logic was correct. A signed “investor approved” message tells you nothing about whether the eligibility calculation considered all required factors or handled edge cases properly.

When regulators audit these decisions or when disputes arise, “our system says it worked” isn’t sufficient. Audits could reveal that conflicting jurisdictional rules are being applied inconsistently across portfolios, but platforms can’t demonstrate which decisions were affected or prove their resolution logic is sound. The computation itself remains a black box.

How Verification Solves the Trust Problem

Verification transforms this challenge by proving code executions and API calls. Instead of trusting that compliance rules executed correctly, verified compute generates cryptographic proofs that demonstrate each step of the calculation. The cryptographic proof contains a step-by-step mathematical demonstration that each rule was applied correctly, including how conflicts between jurisdictional requirements were resolved and which data sources were consulted.

Consider when US and EU privacy laws conflict over data retention for a rejected investor – the proof shows exactly how the algorithm prioritized requirements and which compliance framework took precedence. Auditors and regulators can independently verify that the eligibility algorithm processed all relevant data, applied rules correctly, and reached the right conclusion – without needing to trust the platform or re-run the computation.

This shifts compliance from a “trust us” model to mathematically verifiable governance. The proof itself becomes the audit trail, providing unprecedented transparency into how compliance decisions were made.

Truebit Verified Compliance: The Financial Control Plane

This is where Truebit Verified Compliance delivers. Built on our foundational verification platform Truebit Verify, it’s the financial control plane for digital assets – an execution layer that enforces policy in real-time at the smart contract level and proves every action with cryptographically verifiable evidence.

The Four Pillars of Verifiable Controls

Govern: Enforce policies like eligibility, limits, and jurisdictional restrictions directly on-chain with modular rules that can be updated without redeploying assets.

Automate: Orchestrate complex workflows at scale, including investor onboarding, KYC/AML, and disclosure delivery, with verified execution at every step.

Integrate: Link on-chain assets seamlessly with verified offchain systems through open APIs and adapters, preserving both institutional and DeFi compliance standards.

Prove: Every policy decision and workflow execution emits auditable, cryptographic proofs that create tamper-evident transcripts, allowing regulators and auditors to verify outcomes independently.

Built Different: Why Verification Matters

Truebit Verified Compliance is designed as an integral layer of programmable trust. Where others offer static rule configuration tools that create new black boxes, we provide end-to-end transparency through computational verification.

Most importantly, existing platforms cannot prove their rules were evaluated correctly – they still rely on the “trust us” model. Our technology ensures that every compliance decision can be independently validated through cryptographic proof.

Enabling the Next Generation of Tokenized Finance

Early applications of Truebit Verified Compliance span multiple sectors driving the convergence of TradFi and DeFi.

Stablecoin issuers enforcing transfer restrictions and regulatory compliance without sacrificing compliance standards across DeFi protocols
Private credit funds offering tokenized yield to accredited investors with automated eligibility verification and distribution management
Tokenized treasury platforms balancing institutional auditability requirements with operational flexibility
Infrastructure startups bridging traditional securities with permissioned DeFi rails while maintaining regulatory compliance

Proven Foundation

Truebit established the foundational technology that enabled Layer 2 blockchain scaling solutions, now a multi-billion dollar infrastructure sector. Our verified orchestration platform has evolved to provide verification infrastructure for the rapidly growing tokenized finance and digital asset economy, addressing key institutional concerns around transparency, counterparty risk, and operational integrity.

Ready to Lead the Future of Finance?

The tokenized asset market is projected to reach $10 trillion by 2030, but compliance remains the primary bottleneck. With computational verification as the foundation, you can confidently launch and manage compliant tokenized funds, scale operations at market speed, and participate in the financial revolution without sacrificing institutional-grade standards.

Ready to build on a foundation of trust? Contact us for a personalized demo and learn how Truebit can eliminate the tradeoff between growth and control.

The post Unlocking the Trillion-Dollar Tokenization Opportunity: Why Compliance is a Verification Problem first appeared on Truebit - Don’t just trust, verify.

Truebit Launches Verifiable Compliance for Digital Assets

Truebit — Mon, 15 Sep 2025 03:56:39 +0000

Truebit Launches New Verified Compliance Solution Addressing Critical Infrastructure Gap in the Convergence of Traditional Finance and DeFi with Programmable Compliance

NEW YORK, NY – September 15, 2025 – Truebit, a leading verification services provider, today announced the launch of Truebit Verified Compliance, the industry’s first comprehensive financial control plane for digital assets. The application enforces policy in real-time at the contract level and proves every action end-to-end with cryptographic verification.

Truebit Verified Compliance addresses the critical chokepoint facing financial institutions: the forced choice between growth and control. As fund executives push into tokenized finance, they are no longer just managing assets—they are managing legal obligations in real-time. With the tokenized asset market projected to reach $10 trillion by 2030, and major institutional players like BlackRock, Franklin Templeton, and JPMorgan already deploying tokenized funds, compliance has emerged as the primary bottleneck preventing broader adoption of programmable finance.

Truebit Verified Compliance eliminates this tradeoff by giving fund teams a programmable compliance engine built to enforce policies at the protocol layer without sacrificing compatibility or velocity. Built natively on the ERC-3643 standard, the platform enables institutions to automate reserves verification, NAV calculation, risk management, and ownership/transfer controls.

“We’re witnessing the emergence of ‘policy as code’ – a fundamental shift where legal and regulatory requirements become executable smart contract logic rather than manual processes,” said Jason Teutsch, Founder of Truebit. “Traditional compliance relies on trust and post-hoc verification. Our platform transforms the traditional approach by providing cryptographic proofs that demonstrate policy enforcement happened correctly, creating an auditable trail that regulators, auditors, and counterparties can verify independently. Essentially it’s mathematically verifiable governance.”

Solving the Convergence Challenge

The launch comes as four powerful market forces converge to make programmable compliance essential infrastructure.

Institutionalization of On-Chain Assets: Major asset managers are deploying tokenized funds, but require embedded KYC/AML, sanctions screening, and jurisdictional controls that current infrastructure cannot provide at the smart contract level. A compliance engine becomes the trust layer that allows institutional assets to move on public chains.
Stablecoin Regulatory Maturity: With stablecoins surpassing $230 billion in market cap and new regulatory frameworks like the U.S. GENIUS Act imposing licensing and verification requirements, automated compliance has become critical for institutional adoption.
Identity and Jurisdictional Fragmentation: The global nature of digital assets colliding with fragmented national regulations creates complex cross-border compliance requirements that manual processes cannot efficiently manage. Verified governance serves as a modular, jurisdictional, policy router and enforces rule sets dynamically based on user, asset, and context.
Smart Contracts as Regulated Surfaces: Governments are increasingly targeting technical enforceability at the contract level and requiring compliance to be embedded in the runtime layer rather than relying on legal documentation alone.

“The tokenization of real-world assets is accelerating at an unprecedented pace,” said Travis John, Founder of RWA Builders, a leading consultancy for tokenized asset strategies. “However, this explosive growth is creating a compliance nightmare. Traditional manual processes simply cannot keep pace with 24/7 global markets and programmable finance. Truebit Verified Compliance represents the missing infrastructure layer that will enable funds to tokenize at the speed the market demands while maintaining institutional-grade compliance standards.”

Differentiated by Verifiable Compute Foundation

Truebit Verified Compliance serves as an integral layer of programmable trust. Built on Truebit’s industry-leading verified orchestration platform, it enables the platform to prove adherence to compliance via auditable execution transcripts.

Four-Pillar Architecture Delivers Complete Control Plane Truebit Verified Compliance operates through four foundational capabilities.

Govern: Enforces policies directly on-chain at the contract layer, including eligibility requirements, transfer limits, jurisdictional restrictions, and disclosure mandates.
Automate: Orchestrates complex workflows at scale, including onboarding, KYC/eligibility verification, and disclosure delivery, all without custom code or vendor lock-in.
Integrate: Links seamlessly to identity providers, accounting systems, tax platforms, and custodians via open adapters and APIs, preserving both institutional and DeFi standards compatibility.
Prove: Serves as the execution layer for all automations and integrations, emitting audit-grade, cryptographic proofs that create tamper-evident transcripts bound to on-chain state for regulators, auditors, and counterparties.

Enabling the Next Generation of Tokenized Finance Early applications of Truebit Verified Compliance span multiple sectors driving the convergence of traditional and decentralized finance:

Stablecoin issuers enforcing transfer restrictions and regulatory compliance without sacrificing standards compatibility across DeFi protocols
Private credit funds offering tokenized yield to accredited investors with automated eligibility verification and distribution management
Tokenized treasury platforms balancing institutional auditability requirements with operational flexibility
Infrastructure startups bridging traditional securities with permissioned DeFi rails while maintaining regulatory compliance

Market Leadership Built on Proven Innovation

Truebit established the foundational technology that enabled Layer 2 blockchain scaling solutions, now a multi-billion dollar infrastructure sector. The company’s verified compute platform has since evolved to provide verification infrastructure for the rapidly growing tokenized real-world asset sector, addressing key institutional concerns around transparency, counterparty risk, and operational integrity.

Availability and Next Steps

Truebit Verified Compliance is available immediately for institutional customers, with integration support for major token standards and enterprise systems. For more information about Truebit Verified Compliance and to schedule a demonstration, visit www.truebit.io.

About Truebit

Truebit is a pioneer in secure digital asset infrastructure and verification technology. Founded by Jason Teutsch, the company established foundational technology for Layer 2 blockchain scaling solutions and continues to lead innovation in programmable trust infrastructure. Truebit’s verification platform enables secure, auditable processing for the emerging tokenized real-world asset sector, addressing critical institutional requirements around transparency and operational integrity. For more information, visit www.truebit.io.

Media Enquiries: [email protected]

The post Truebit Launches Verifiable Compliance for Digital Assets first appeared on Truebit - Don’t just trust, verify.

Verifiable by Default: Transforming IoT Networks into Trusted DePIN Infrastructure

Truebit — Tue, 22 Jul 2025 09:26:05 +0000

As IoT networks expand exponentially, they’re increasingly converging with blockchain incentive structures to create Decentralized Physical Infrastructure Networks (DePIN) – one of Web3’s most promising application categories. These community-owned networks rely on distributed IoT devices to provide real-world services ranging from wireless connectivity to environmental monitoring.

However, this convergence introduces a critical challenge: establishing trust in data and computations across a network where participants don’t inherently trust each other. This is where Truebit Verify becomes essential, providing the verification layer that bridges physical infrastructure with blockchain incentives.

Truebit Verify and the Internet of Things (IoT)

IoT devices are electronic systems equipped with sensors that collect data about their surroundings. Once this data is gathered, the devices process and transmit it over the internet. For example, these low-cost devices are deployed over extensive areas to collect meteorological and soil data for efficient farming. They are typically sealed to be airtight and are not designed for servicing; their non-removable batteries determine their lifespan. Therefore, ultra-low power operation is essential.

Truebit can support a swarm of IoT devices in processing and integrating their collective data, helping to conserve battery life, extend device lifespan, and reduce costs associated with centralized IT infrastructure.

Data Integration, Analysis, and Reporting with Truebit Tasks

When required, IoT devices send the collected raw data to a designated function task for analysis. After sending the data, they immediately return to a deep sleep mode to conserve energy. The selected Truebit function task performs often CPU-intensive calculations and securely stores the results, ensuring that the data used for further analysis or reporting is verified. The task can also feed data into a suitable machine learning model for accurate predictions. Finally, it generates a final PDF report that includes soil metrics and additional recommendations for decision-making. Each Truebit function task guarantees that the computation, integration of measurements, algorithms, and final report are all verified.

An Alternative to Costly IoT Over-the-Air Updates

One challenge with IoT deployments is updating firmware for bug fixes or new functionalities. With Truebit, IoT devices can simply update the specific function task name or task ID they need to execute, which involves only a few bytes of information. Changing algorithms becomes much more convenient, eliminating the need for extensive, risky, and power-intensive firmware updates.

The Need for Verifying IoT Data and Algorithms

Ensuring data integrity and confirming that algorithms function correctly is crucial. Given the massive volume of data generated by IoT devices, manual inspection and verification are no longer practical. Quality data is vital for data science, and having confidence in executing algorithms accurately is essential for the quality of reports for decision-making.

Truebit enhances data accuracy for IoT applications by allowing a function task to sample data from multiple IoT devices belonging to different stakeholders in the same area. It also secures the data processing by running algorithms in a verifiable manner. Generating the final report using a Truebit function task ensures that all participants receive the same unbiased and unaltered information.

Powering the DePIN Revolution with Trusted IoT

DePIN represents a fundamental shift in how we build and operate infrastructure, moving from centralized corporate ownership to community-driven networks. This model is already transforming multiple sectors:

Decentralized Wireless Networks: Communities deploying and operating telecom infrastructure, sharing revenue based on usage
Distributed Compute Networks: Participants contributing spare computing resources to create alternatives to centralized cloud providers
Environmental Monitoring Networks: Collaborative sensor deployments creating verified environmental data commons
Energy Microgrids: Peer-to-peer energy networks balancing local production and consumption

What unites these diverse applications is their dependence on trusted IoT data and verifiable computation. For DePIN to succeed at scale, networks need assurance that:

Physical devices are honestly reporting real-world conditions
Computational tasks determining rewards are executed correctly
Network participants receive fair compensation based on actual contributions

Truebit Verify addresses these requirements by providing transparent verification for the entire data lifecycle – from collection by IoT devices to processing and reward distribution. This creates the foundation of trust necessary for DePIN networks to scale beyond experimental deployments to mainstream infrastructure alternatives.

IoT Market Growth

As the IoT sector continues to grow, the market for complementary decentralized technologies is expanding in parallel, with DePIN emerging as one of the fastest-growing segments of Web3.

Gartner predicts that the global IoT market will nearly double from $546 billion in 2022 to $991 billion by 2028, with a compound annual growth rate (CAGR) of 10.3%. The DePIN market is forecasted to reach $3.5 trillion by 2028 (source: Life News Agency), representing one of the largest addressable markets for Web3 applications. Early-stage DePIN funding surged 296% in 2024, with AI-powered projects accounting for nearly half of all funded projects (source: Socialcapitalmarkets).

IoT devices are projected to reach 40 billion by 2030 (source: IoT Analytics), while the DePIN sector is accelerating even faster – growing to a $25 billion market capitalization with over 2,300 projects (source: Socialcapitalmarkets)in just a few years.

The parallel growth of both IoT and DePIN markets signals a fundamental shift in how infrastructure is deployed, operated, and monetized—with verification serving as the essential trust layer that makes these new models viable at scale. As these technologies converge, Truebit Verify is positioned to provide the critical verification infrastructure needed to ensure trust and transparency in this rapidly expanding ecosystem.

Verification as the Foundation for DePIN Growth

The IoT market is rapidly expanding and is expected to experience significant growth in the coming years. As these devices increasingly power DePIN networks, verification becomes the foundation for sustainable economic models.

Truebit Verify supports this emerging ecosystem by:

Enhancing power efficiency for energy-constrained devices deployed across DePIN networks
Reducing costs associated with centralized IT infrastructure through efficient verification
Facilitating collaboration among various stakeholders to gather data from different sources
Ensuring transparency and reliability in data processing that determines economic rewards
Producing unaltered final reports that serve as input for network governance and decision-making

As DePIN continues to mature as one of Web3’s most promising real-world applications, verification technologies will be essential to bridging the gap between physical infrastructure and decentralized incentive systems – ultimately enabling a more democratic, resilient, and transparent approach to building critical infrastructure.

Thank you to our guest blog contributor Santiago Germino. Santiago is a Low-Level Systems Engineer with 20+ years of experience and a passion for delivering innovative solutions across diverse platforms. He is currently a PhD candidate at the University of Buenos Aires, focusing on Methods for Embedded Critical Systems Verification, Validation, and Certification.

Ready to build verifiable applications? Get started with Truebit Verify and transform your application’s trust model.

The post Verifiable by Default: Transforming IoT Networks into Trusted DePIN Infrastructure first appeared on Truebit - Don’t just trust, verify.

The GENIUS Act Reality Check: What Banks Actually Need to Prove

Truebit — Fri, 18 Jul 2025 01:07:27 +0000

Building stablecoin infrastructure that proves compliance in real-time involves a fundamental technical challenge: how do you verify that traditional banking systems accurately interface with blockchain infrastructure?

While the GENIUS Act promises regulatory clarity for stablecoin issuance, beneath its framework lies a complex web of demands on financial institutions.

The Current Compliance Gap

Today’s financial compliance relies on periodic audits and trust-based attestations. Banks report reserves monthly while auditors verify quarterly. These processes inherently require assumptions that systems worked correctly between reporting periods, however this approach breaks down when regulation demands continuous, real-time verification.

The technical complexity is significant: reserve management systems query Federal Reserve APIs, custodial account balances, and Treasury market data. Those responses feed into blockchain-based token issuance decisions. If any component fails silently or suffers unexpected bias, banks face regulatory exposure wherein traditional audit trails can’t prove what actually happened.

The challenge isn’t just technical reliability; it’s verifiable reliability, namely proof that data originated from expected sources and processed correctly.

Real-Time Reserve Verification

The GENIUS Act mandates monthly public disclosure of reserve composition, with CEOs and CFOs personally certifying accuracy under criminal penalty. For context, Circle’s USDC has over $40 billion in circulation, requiring daily verification of Treasury bill holdings and bank deposits across multiple institutions.

When Circle queries Federal Reserve systems to verify its Treasury holdings or checks balances across its network of regulated banks, how does it prove those API responses weren’t intercepted or modified? A single corrupted data feed could trigger false reserve calculations affecting billions in stablecoin backing.

Traditional audit trails catch problems after the fact, but real-time verification prevents them by creating certified transcripts of every API interaction – proof that data came from the claimed source, arrived unaltered, and was processed according to documented procedures.

Cross-System Integration Under Pressure

Consider JPMorgan’s JPM Coin, which processes over $1 billion in daily transactions for institutional clients. If Treasury’s OFAC issues a sanctions alert requiring immediate token freezes, JPMorgan would have to prove their traditional compliance systems correctly identified target addresses and executed blockchain-based freezes without delay or error.

The compliance question isn’t just whether the bank can execute these orders but whether it can prove the integration worked as designed. If a freeze order fails, was it a technical malfunction, human error, or system compromise? Without verification, forensic analysis becomes complex and expensive while regulatory exposure continues.

Building Competitive Advantage

As we speak (or type, rather) the GENIUS Act has passed both chambers of Congress and is now awaiting the President’s signature to become law. Major stablecoin issuers like Circle, Paxos, and potentially new entrants like JPMorgan will likely need to implement verification capabilities within the next 18 months. The institutions that solve these technical challenges first will have significant competitive advantages in the growing stablecoin market.

The GENIUS Act represents a new foundation for a verified economy where financial institutions can prove their operations rather than simply assert them. Banks that embrace verification technology will lead the industry with lower risk products and trust in digital asset issuance.