SAUCE SDK

Your onchain harness for failsafe execution

Write transaction logic in SauceScript, a subset of TypeScript. Sauce reads live onchain state, chooses the best path, and executes it atomically in the same transaction, with no extra block between reading state and acting on it. Launch support for Ethereum, Base and Solana.

START BUILDING

EXPLORE RECIPES

$npm install @eco-incorp/sauce

main.tsEXECUTE
1// This whole function executes on-chain, inside one transaction.
2function main() {
3  const a = quote(tokenIn, tokenOut, amount, poolA);
4  const b = quote(tokenIn, tokenOut, amount, poolB);
5  return swap(tokenIn, tokenOut, amount, a > b ? poolA : poolB);
6}

What is Sauce?

Sauce is a Turing-complete runtime for the EVM and SVM. Your program reads live state from any number of contracts, branches on what it finds, and takes the best path by composing them at execution time. No contract to deploy, and no extra block between reading state and acting on it. Your program enforces the conditions you write. Launch support for Ethereum, Base and Solana; see supported chains and preview availability.

$npm install @eco-incorp/sauce

LEARN MORE →

Deploy your first Sauce transaction in minutes

Three copy-pasteable paths from install to a compiled program.

$npm install @eco-incorp/sauce

import { routes } from "@eco-incorp/sauce";

const now = BigInt(Math.floor(Date.now() / 1000));

const built = routes
  .openRoute("base", `function main() { USDC.transfer(${recipient}n, 1_000_000n); return 0n; }`, {
    source: "ethereum", pot, portal, sourcePortal, creator, prover,
    deadline: now + 3600n, rewardDeadline: now + 7200n,
  })
  .reward([{ token: usdc, amount: 1_000_000n }]);

built.intent;             // the assembled cross-chain intent
built.publishCalldata();  // calldata to publish it

ASK AI

Requires Node 24+ for this quickstart. Compiling in the browser needs await ready() and the WASM asset. See browser setup.

How Sauce Works

Off-chain orchestrationThe decision is made off-chain before submission; by the time it lands, the chain has moved.

Decision age at landing3 blocks

SauceQuote, decide and execute in the same transaction. No additional block between reading on-chain state and acting on it.

Decision age at landing0 blocks

One language for EVM and Solana: shared logic compiles to both targets. See language and target limits.

Faster, Safer Onchain Development

Programmability

if/else, loops, recursion, cross-call data flow, all evaluated against live state at inclusion.

→ See it: best-pool swap

One language for EVM and Solana

Shared logic compiles to both targets; target-specific calls, storage and Solana account setup differ. See language and target limits.

→ See it: the same recipe on both targets

TypeScriptSolidityRust+ token & protocol bindings

Accessibility, deploy faster

TypeScript, not Solidity or Rust, with built-in token and protocol bindings, resolved for your target chain. Builders generate the program for you.

→ See it: protocol bindings

Step 1Step 2✕ Step 3

Output < floor → revert allNo partial state left behind

Atomic by construction

The whole program runs as one transaction: an unhandled failure reverts every step in it. Your script sets what counts as failure, from a minimum output to a price limit.

→ See it: settle-with-floor

> swap through the best pool

✓ Sourcemain.ts

✓ Compilebytecode

✓ Simulatepasses

Signyou approve, separately

Agent-native, out of the box

Give your coding agent Sauce's protocol context and tools to discover, compile and simulate transaction programs, with signing as a separate step.

→ See it: agent skills

Recipes

Runnable programs, each with full source and live execution. New here? Start with best-pool swap.

best-pool swapStart hereQuote each supplied pool in-transaction, route through the best of them.Source + run →settleRead a Pot's balance, revert the whole cook if output falls below a floor.Source + run →cctp-splitSplit an amount across capped burns with a loop.Source + run →order-splitSplit across N pools, execute sequentially, recombine against a floor.Source + run →ERC-20The language showcase: transfer-like behavior in 11 lines of TS.Source + run →

Trust & Security

Private Pot

Owner✓ can execute

Anyone else✕ cannot

Non-custodial by architecture.

Programs run inside a Pot. On private Pots, only the owner can execute. See the security model for shared and intent Pots.

→ Security model

Pinned compiler · same settings

Build A0x6080 6040 5234 8015 …

Build B0x6080 6040 5234 8015 …

= Match: reproducible

Byte-verifiable output.

Rebuild a program with the same pinned compiler, dependencies and settings, and compare the resulting bytecode. A match shows the build is reproducible, not that the script is safe.

→ See audit reports

Get Started

Self-serve first: install the SDK, or call the hosted routing APIs.

Self-serve · SDK

Full Expression

Install the SDK and write your own. Full programmability, your scripts in your repo, compiled locally, byte-verifiable.

$npm install @eco-incorp/sauce

✓Full programmability

✓Your scripts in your repo

✓Compiled locally

✓Byte-verifiable

Start building Browse recipes

Hosted · API

Cross-Chain Routing & Swap Execution

Call hosted routing APIs. For partners who need template swaps and would rather integrate an endpoint than a toolchain: Eco's /quote and /swap endpoints run production swaps through our EcoSwap Sauce script.

/quoteEcoSwap Sauce script

/swapEcoSwap Sauce script

Explore the APIs Talk to the team