Documentation

Run your first task

The workspace uses local test units and a manual clock
Every action runs in your browser

1. Create a task

   Open the workspace and choose Open your workspace to leave the example
   Then choose Create a task
   Keep the standard terms or choose a small transfer, then select Prefund and create task

2. Reserve the bond

   Select Accept and reserve bond
   The customer amount and fee are already reserved — the provider contributes separate collateral

3. Execute within the window

   If the start is in the future, use Go to execution start
   Select Execute transfer to credit the recipient and release the fee and bond

4. Keep the result

   Select Export receipt for that task
   Use Workspace data to export a replayable backup of every task

Find the task, keep the context

Tasks shows obligations and their available actions
Capital shows independent reservations and final allocations
Activity shows the actual local action history

Your workspace and the example

With no saved workspace, an interactive example opens first
Example changes stay in the current tab and never replace saved tasks

Choose Open your workspace to create or restore your own local tasks
Explore example returns to a fresh example without changing them

Select a task from Capital or Activity to inspect it in Tasks
The shared clock affects every local obligation

Search accepts a task name, local task ID or displayed state
The active and settled filters combine with the search

Sort by creation order, earliest deadline or largest transfer
Select a task to see its full terms, clock, available actions, allocation and history

Reuse a set of terms

Use these terms copies the selected agreement into a new draft
It does not reserve funds, copy the outcome or alter the original task

The copied start delay is relative to the current shared clock
Review the funding preview before creating the new task

Default starting balances

These balances belong to the local model
They are not wallet balances or a faucet allocation

Two contributions, kept separate

Creating a task reserves the transfer amount and service fee from the customer
Accepting it reserves the bond from the provider

The provider cannot accept another obligation with collateral that is already reserved
The funding preview shows how each available balance changes

If there are not enough units

An underfunded customer cannot create the task
A task can be created while the provider is short of collateral, but acceptance remains unavailable until enough provider units are free

Settle or cancel other local tasks to release their contributions
Each active task keeps its own reservation

The deadline is a strict boundary

A task with a 10 minute delay and a 30 minute window created at minute 0 can execute from minute 10 until just before minute 40

executeAfter <= clock < deadline

The time track distinguishes the waiting period from the execution window
Its vertical marker follows the shared test clock and stops at a settled task outcome

Move the clock deliberately

Advance by 5 minutes, jump to a task boundary or open Advance clock
Custom advances accept 1 to 10080 whole minutes

The clock affects every task in this workspace
Reaching a deadline does not settle a task automatically

Cancellation needs both parties

Customer and provider approvals are separate and revocable until settlement
One approval does not stop execution or timeout settlement

Both approvals settle the task immediately
The agreement cannot settle a second time

Backups that can be replayed

The workspace saves in this browser when storage is available
Export a backup to keep a separate copy

A backup contains starting balances and the action history
Import replays those actions rather than trusting supplied balances or outcomes

Import a backup

Open Workspace data and choose Import backup
Choose a Serrin JSON backup smaller than 1 MB, review the task count and confirm replacement

Import replaces the current local workspace
It does not merge two histories or change any blockchain state

When storage is unavailable

The toolbar changes to This tab only
You can keep using the workspace and export before closing the tab

If stored data cannot be read, the workspace preserves it and offers a recovery download
A temporary workspace lets you continue without replacing that stored data

CSV is a report

Export task ledger as CSV produces one row per task with its terms, times, state and final allocation
It is useful for a spreadsheet and cannot be imported as a backup

A receipt describes one result

A settled task can export a local receipt containing its immutable terms, timing and allocation
The quick example on the overview page has its own illustrative receipt format

Both formats explicitly identify local test data
They contain no wallet signature, transaction hash or proof of a real transfer

What the checker establishes

The checker recomputes a receipt allocation from its terms and outcome
For a workspace backup it replays every action and checks the resulting ledger

Consistent data may still have been written or edited by anyone
A successful check establishes internal consistency, not authorship or onchain execution

Check a receipt or backup

Paste a Serrin JSON export or choose a local file
The contents stay in this page and are not uploaded

A small local API

The workspace engine is an ES module with no runtime dependencies
State transitions return a new frozen state and preserve the total test-unit supply

import {
  createWorkspace,
  dispatch,
  taskReceipt
} from './dist/workspace-engine.mjs';

let state = createWorkspace();
state = dispatch(state, {
  type: 'create',
  payload: {
    name: 'Scheduled payment',
    amount: 1000, fee: 2, bond: 20,
    delay: 0, duration: 30
  }
});

const id = state.tasks[0].id;
state = dispatch(state, { type: 'accept', payload: { id } });
state = dispatch(state, { type: 'execute', payload: { id } });

const receipt = taskReceipt(state, id);

The bundle includes the engine, view helpers, receipt checker, examples and tests
It runs locally and does not connect to a wallet

Reproduce the examples

node examples/settle.mjs
node --test test/*.test.mjs

Read the testnet separately

The testnet page reads Robinhood Chain testnet with chain ID 46630
It verifies the chain before requesting balances or contracts

Account and contract readings are pinned to the same block
The displayed read time belongs to the last successful snapshot

Look up a transaction

Open Transaction lookup on the testnet page and enter a transaction hash
The reader verifies chain 46630 before requesting the transaction and its receipt

Included transactions are checked against their canonical block
Amounts and receipt gas charges retain exact integer precision

A reading can be linked, exported or reopened from the last eight checks saved in this browser
These are RPC observations, not signed receipts, task fulfillment proof or Ethereum finality

If a refresh fails

A failed first read shows no verified balances
A failed later refresh keeps the last verified snapshot and its timestamp

The page does not turn a funded account into a deployed-contract claim
Contract addresses and transaction receipts are shown only when published by the project configuration and verified where applicable

Testnet readings and local workspace units are separate
Creating a local task does not submit a transaction or move test ETH

Know the boundaries

100 tasks

Maximum per local workspace

2000 actions

Maximum replayable history per backup

1 MB

Maximum imported backup or checked JSON document

Whole test units

No fractional amounts in the local model

There is no wallet connection or onchain task submission in this release
The Solidity core is a separate, undeployed and independently unaudited prototype

An execution bond has a fixed responsibility limit
It does not guarantee returns or cover every asset, market, network or contract risk