Signet – Same Block on Signet

Authentication

Mon, 01 Jan 0001 00:00:00 +0000

Authentication

Overview

Authentication will be required for the following behaviors:

Getting a sequencer co-signature on a built block.
Retrieving bundles from the bundle relay.

Authentication will be performed using a standard OAuth2 client credential grant and then the access token you receive can be used to authorize all requests to the sequencer and bundle relay.

OAuth Identity Provider Reference

Havarti


Issuer	`https://auth.havarti.signet.sh/realms/master`
OAuth `.well-known` URL	`https://auth.havarti.signet.sh/realms/master/.well-known/openid-configuration`
Authorize Endpoint	`https://auth.havarti.signet.sh/realms/master/protocol/openid-connect/auth`
Token Endpoint	`https://auth.havarti.signet.sh/realms/master/protocol/openid-connect/token`

Authenticating Using `curl`

First off a basic example of getting an OAuth2 access token and using it to authenticate any of our secured API’s

Build from source

Mon, 01 Jan 0001 00:00:00 +0000

Build From Source

Installation

Clone the repository

bash

git clone https://github.com/init4tech/signet.git

Build the binary
bash
```
cargo build --release --bin signet
```
Download a binary from github releases
Configure the environment variables as needed
Copy the binary from the release to a location in your users path

Environment variables

Mon, 01 Jan 0001 00:00:00 +0000

Environment Variables

The Builder is configured via environment variables. The following values are supported for configuration.

Key	Required	Description
`HOST_CHAIN_ID`	Required	Host-chain ID (e.g. 3151908)
`RU_CHAIN_ID`	Required	Rollup-chain ID (e.g. 88888)
`HOST_RPC_URL`	Required	RPC endpoint for the host chain
`ROLLUP_RPC_URL`	Required	RPC endpoint for the rollup chain
`TX_POOL_URL`	Required	Transaction pool URL (must end with /)
`FLASHBOTS_ENDPOINT`	Optional	When configured, the Builder will send Signet blocks to this URL as transaction bundles
`TX_BROADCAST_URLS`	Optional	Additional endpoints for blob txs (comma-separated, slash required)
`ZENITH_ADDRESS`	Required	Zenith contract address
`BUILDER_HELPER_ADDRESS`	Required	Builder helper contract address
`QUINCEY_URL`	Required	Remote sequencer signing endpoint
`BUILDER_PORT`	Required	HTTP port for the Builder (default: 8080)
`SEQUENCER_KEY`	Required	AWS KMS key ID or local private key for sequencer signing
`BUILDER_KEY`	Required	AWS KMS key ID or local private key for builder signing
`BUILDER_REWARDS_ADDRESS`	Required	Address receiving builder rewards
`ROLLUP_BLOCK_GAS_LIMIT`	Optional	Override for block gas limit
`CONCURRENCY_LIMIT`	Optional	Max concurrent tasks the simulator uses
`OAUTH_CLIENT_ID`	Required	Oauth client ID for the builder
`OAUTH_CLIENT_SECRET`	Required	Oauth client secret for the builder
`OAUTH_AUTHENTICATE_URL`	Required	Oauth authenticate URL for the builder for performing OAuth logins
`OAUTH_TOKEN_URL`	Required	Oauth token URL for the builder to get an Oauth2 access token
`AUTH_TOKEN_REFRESH_INTERVAL`	Required	The OAuth token refresh interval in seconds.
`CHAIN_NAME`	Required	The name of the chain (e.g. `parmigiana`)

Fetching transactions

Mon, 01 Jan 0001 00:00:00 +0000

Transactions can be fetched from Signet’s transaction cache. Fetching transactions is easy with Signet’s Transaction Cache Client. Consult the Parmigiana Quickstart for any other RPC endpoints or contract addresses you might need.

Getting transactions and bundles

Mon, 01 Jan 0001 00:00:00 +0000

Getting Transactions and Bundles

The transaction cache offers endpoints for getting simple transactions and Flashbots-style transaction bundles.

Fetching bundles requires authentication. This is because Builders are only allowed to build blocks for their assigned slots. See Authentication for details.

Transaction cache basics:

API Endpoint: transactions.api.signet.sh
Cache Duration: 10 minutes
Authentication: Authentication is required to retrieve bundles, but not to retrieve transactions.

API Endpoints

Get Transactions

http

GET /transactions

Returns a list of transactions available for inclusion in a block.

Bundle guarantees

Mon, 01 Jan 0001 00:00:00 +0000

Bundle Guarantees

Signet bundles are Flashbots-style bundles of transactions wrapped with a host_fills field.

When building blocks containing Signet orders, the atomicity constraints apply to host_fills as well, meaning that if a host_fill is included and no corresponding rollup transaction is included, it would be considered invalid.

Bundle Guarantees

Block Builders should respect the following guarantees around bundles when building blocks.

Ordering: The transaction ordering in a bundle must be preserved.
Atomicity: Bundles won’t be split up and will be applied as a contiguous block of transactions or won’t be applied at all.
Revertibility: Transactions in a bundle won’t revert unless explicitly marked as revertible.

Docker

Mon, 01 Jan 0001 00:00:00 +0000

Docker

Installation

Pull image from Github Container Repository
bash
```
docker pull ghcr.io/init4tech/signet:latest
```

Run the container, specifying the environment variables as needed

 bash
 
 
docker run -d \
 -e BLOB_EXPLORER_URL=value \
 -e SIGNET_STATIC_PATH=value \
 -e SIGNET_DATABASE_PATH=value \
 -e IPC_ENDPOINT=value \
 -e RPC_PORT=value \
 -e WS_RPC_PORT=value \
 -e IPC_ENDPOINT=value \
 -e TX_FORWARD_URL=value \
 -e GENESIS_JSON_PATH=value \
 -e BASE_FEE_RECIPIENT=value \
 -e SIGNET_CL_URL=value \
 -e SIGNET_PYLON_URL=value \
 -e HOST_START_TIMESTAMP=value \
 -e HOST_SLOT_OFFSET=value \
 -e HOST_SLOT_DURATION=value

 ghcr.io/init4tech/signet:latest

Signed orders

Mon, 01 Jan 0001 00:00:00 +0000

Signed Orders

Constructing Token Transfers

Assemble Data

Create the outputs array specifying the tokens, amounts, recipients, and destination chain IDs. Construct the permit object listing permitted tokens and amounts, along with the nonce and deadline.

Generate Witness Hash

Hash the outputs array to create a witness hash, ensuring the integrity of the transaction details.

Compiled binaries

Mon, 01 Jan 0001 00:00:00 +0000

Compiled Binaries

Installation

Download binary from github releases
Configure the environment variables as needed
Copy the binary from the release to a location in your users path
bash
```
tar xzf signet-client-v0.1.0-alpha-1 signet
cp signet /usr/local/bin
```

Run Signet

 bash
 
 
signet node \
 --chain parmigiana \
 --authrpc.jwtsecret /path/to/your/jwt.secret \
 --http \
 --http.addr 127.0.0.1 \
 --http.api eth,net,trace,txpool,web3,rpc,debug,ots

Filler

Mon, 01 Jan 0001 00:00:00 +0000

Filler

The Filler struct from signet-orders orchestrates the full order-filling pipeline: fetching pending orders from a source, signing Permit2 fills, and submitting them as bundles. It is the main building block for writing a Signet filler bot.

Example implementation

The signet-filler repository is an example filler built on top of Filler and FeePolicySubmitter. It demonstrates order filtering, metrics, provider setup, and the overall structure of a filler service.

Setup

 bash
 
 
cargo add signet-orders signet-types signet-constants signet-tx-cache
cargo add alloy --features provider-http,signers
cargo add futures-util

Architecture

Filler is generic over three type parameters:

Environment variables

Mon, 01 Jan 0001 00:00:00 +0000

Environment Variables

The following environment variables can be used to configure various aspects of the signet node client.

Environment Variable	Required	Description
`BLOB_EXPLORER_URL`	Required	URL of a blob explorer
`SIGNET_STATIC_PATH`	Required	Filesystem path to where the static_files directory should be located
`SIGNET_DATABASE_PATH`	Required	Filesystem path to where the node should store its database
`IPC_ENDPOINT`	Optional	Filesystem path for the .ipc file
`GENESIS_JSON_PATH`	Required	Path on the filesystem for the genesis file
`RPC_PORT`	Required	Port to be used for the rollup node http json-rpc requests
`WS_RPC_PORT`	Required	Port to be used for the rollup node’s WebSocket connections
`TX_FORWARD_URL`	Optional	URL for the transaction cache API
`SIGNET_CL_URL`	Optional	URL to the consensus layer for fetching blobs and other CL responsibilities
`SIGNET_PYLON_URL`	Optional	URL to the Pylon node for blob storage
`HOST_START_TIMESTAMP`	Required	The host chain’s start timestamp for slot calculation purposes
`HOST_SLOT_OFFSET`	Required	The host chain’s slot offset
`HOST_SLOT_DURATION`	Required	The host chain’s slot duration
`RUST_LOG`	Optional	Standard rust environment variable for logging

Getting a sequencer signature

Mon, 01 Jan 0001 00:00:00 +0000

Getting a Sequencer Signature

Blocks must be cosigned by the Sequencer. The Sequencer blindly signs any number of candidate blocks for the current Builder via a simple API.

The Sequencer API accepts a SignRequest via a POST call to the /signBlock endpoint, and returns a SignResponse. For details on calculating the contents hash, see the rust builder example.

The sequencer is allowed to modify the returned copy of the SignRequest. This is to allow the sequencer to set a specific gas_limit. It currently does not modify the request before returning it, but may do so in the future.

Slot Timing

Quincey follows a round-robin sequencing approach, allowing builders to request block signatures according to their spot in the rotation.

Parmigiana quickstart

Mon, 01 Jan 0001 00:00:00 +0000

Parmigiana quickstart

Parmigiana Testnet

Host Chain ID 3151908

Rollup Chain ID 88888

Deploy Height 0

Native Gas Token USD

Rollup RPC rpc.parmigiana.signet.sh

Host RPC host-rpc.parmigiana.signet.sh

Rollup Explorer explorer.parmigiana.signet.sh

Host Explorer explorer-host.parmigiana.signet.sh

TX Cache API transactions.parmigiana.signet.sh

Parmigiana is Signet’s public testnet for rollup and application experimentation. This page contains the faucet, RPC endpoints, and contract addresses you need to get started.

These constants are also available to Rust code via the signet-constants crate. If you need to test applications that interact with both host and rollup chains, please reach out.

Chain configuration

Mon, 01 Jan 0001 00:00:00 +0000

Chain Configuration

See signet-constants for loading and interacting with genesis files and values.

Parmigiana Testnet

Host Chain ID 3151908

Rollup Chain ID 88888

Deploy Height 0

Native Gas Token USD

Rollup RPC rpc.parmigiana.signet.sh

Host RPC host-rpc.parmigiana.signet.sh

Rollup Explorer explorer.parmigiana.signet.sh

Host Explorer explorer-host.parmigiana.signet.sh

TX Cache API transactions.parmigiana.signet.sh

See Parmigiana Quickstart for complete contract addresses.

Getting started

Mon, 01 Jan 0001 00:00:00 +0000

New to Signet? Start with Learn about Signet for background on how the system works.

Select your language to see the relevant setup instructions. Get testnet tokens from the Parmigiana quickstart.

Submitting a block to Ethereum

Mon, 01 Jan 0001 00:00:00 +0000

Submitting a Block to Ethereum

Rollup blocks are submitted to the host chain by calling the Zenith submitBlock function, attaching transaction data in a 4844 blob.

Code Flows

These examples assume one has already chosen a set of transactions and bundles, and gotten a co-signature from the Sequencer API.

Building with Orders

Wed, 20 Aug 2025 12:00:00 +0000

A practical guide to placing and filling cross-chain orders on Signet.

The Filler Economy

Wed, 04 Jun 2025 12:00:00 +0000

How Signet turns MEV extractors into service providers.

How Signet Works

Wed, 30 Apr 2025 12:00:00 +0000

The three pieces that make cross-chain execution feel like one chain.

Enter Signet

Mon, 01 Jan 0001 00:00:00 +0000

Passage is the bridge contract on Ethereum that moves assets into Signet. Deposits arrive on the rollup in the same block they’re submitted.

Passage has two entry points: one for ETH (sent as msg.value) and one for ERC-20 tokens (requires a prior token approval). Both take a rollupRecipient address that receives the tokens on Signet.

The Signet node watches for Enter and EnterToken events on the Passage contract. If the event fired, the deposit was processed – no additional confirmation is needed on the rollup side.

Execute from Ethereum

Mon, 01 Jan 0001 00:00:00 +0000

The Transactor contract provides guaranteed, censorship-resistant execution on Signet from Ethereum. Any Ethereum account can call Transactor to trigger a transaction on Signet that builders cannot censor or reorder.

Overview

Transactor.sol exposes two function signatures for sending transactions to Signet:

Default Chain

 solidity
 
 
function transact(
 address to,
 bytes calldata data,
 uint256 value,
 uint256 gas,
 uint256 maxFeePerGas
) external payable

This version uses the contract’s defaultRollupChainId configured at deployment.

FAQ

Mon, 01 Jan 0001 00:00:00 +0000

FAQ

What is Signet?

Signet is a pragmatic Ethereum rollup designed to offer sustainable economic incentives. It aims to modernize and streamline rollups by simplifying their architecture and focusing on efficiency.

How does Signet differ from traditional rollups?

Signet differs in several key ways:

It doesn’t use proving systems or state roots, which reduces computational overhead.
It uses market-based cross-chain transfers instead of complex bridging mechanisms.
It replaces block auctions and centralized rollup sequencing with a controlled block inclusion mechanism.
It introduces conditional transactions for secure, atomic cross-chain operations.

How does Signet handle cross-chain transfers?

Signet uses market-based mechanisms and conditional transactions for cross-chain transfers. This allows for secure, instant transfers between Ethereum and Signet without the need for lockup periods.

Simplifying the rollup

Mon, 01 Jan 0001 00:00:00 +0000

Simplifying the rollup

Signet is a pragmatic Ethereum rollup with sustainable economic incentives. It offers a new set of ideas, aiming to radically modernize and streamline rollups.

No proving systems or state roots, drastically reducing computational overhead
Market-based cross-chain transfers for instant asset movement
Removes block auctions in favor of a controlled block inclusion mechanism
Introduces conditional transactions for secure, atomic cross-chain operations

Signet is built by Init4, a research collective building next-generation Ethereum.

Bundles

Mon, 01 Jan 0001 00:00:00 +0000

Bundles are ordered sets of transactions that execute atomically. All succeed or all revert. They can span both Signet and Ethereum, enabling cross-chain operations like order fills where both sides must settle in the same block.

Exit Signet

Mon, 01 Jan 0001 00:00:00 +0000

Create and submit orders to move assets from Signet to Ethereum. For background on the order lifecycle and atomic settlement, see How orders work.

Order data model

Every order has inputs (what the user gives up on Signet) and outputs (what they receive on the destination chain).

Input:

Field	Description
`token`	ERC-20 address on Signet. Zero address for native USD.
`amount`	Amount in the token’s smallest unit (e.g., wei).

Output:

Glossary

Mon, 01 Jan 0001 00:00:00 +0000

Glossary

Block Builders

Participants who assemble and propose new blocks. They collect pending transactions, organize them to maximize fees, and submit the block for inclusion.

No proofs or state roots

Mon, 01 Jan 0001 00:00:00 +0000

No proofs or state roots

Rollups extend Ethereum by allowing nodes to track additional data. Traditional rollups face significant complexity when communicating this data back to Ethereum, typically relying on proving systems. Signet takes a different approach.

No proving system

Most rollups use complex proving systems like optimistic or zero-knowledge proofs to communicate with Ethereum. These systems introduce significant overhead and complexity and are not necessary for most users. Instead of a proving system, Signet facilitates cross-chain transfers through markets. Assets are bought and sold between Signet and Ethereum, rather than being “proven” back onto Ethereum.

Permissioned roles

Mon, 01 Jan 0001 00:00:00 +0000

Permissioned Roles

Signet’s smart contracts use a system of permissioned roles to manage access control. Each contract has specific roles that can perform certain administrative functions.

Core Roles

Sequencer Admin

The sequencerAdmin role manages the list of authorized sequencers in the Zenith contract. This role can:

Add or remove sequencers
Update sequencer configuration
Pause sequencing if needed

Sequencer

The sequencer role is responsible for validating and co-signing blocks before they are submitted to the Zenith contract. Sequencers:

Simple sequencing

Mon, 01 Jan 0001 00:00:00 +0000

Simple sequencing

Centralization of Sequencing

Every blockchain needs a way to order transactions — that’s sequencing. Ethereum uses auctions to determine who gets to build blocks and sequence transactions. There are a few problems with this:

Simulating bundles

Mon, 01 Jan 0001 00:00:00 +0000

Once you’ve created a bundle, simulate it against a Signet RPC node before submitting. Simulation lets you verify execution, check profitability, and confirm that order fills are satisfied. The signet_callBundle RPC method is Signet’s equivalent to Flashbots’s eth_callBundle.

Swap within Signet

Mon, 01 Jan 0001 00:00:00 +0000

When you want a different token on Signet without crossing to Ethereum, create an order where both input and output are on the rollup chain. The order stays entirely within Signet and settles without touching Ethereum at all.

For order structure, pricing, and filler economics, see the Exit Signet shared intro. The order model is identical – only the output chainId differs.

System transactions

Mon, 01 Jan 0001 00:00:00 +0000

System transactions

Transactions on Signet can originate from Ethereum. When the Signet node observes specific events from the Passage or Transactor contracts on the host chain, it creates corresponding transactions on the rollup.

Three host-chain event types produce system transactions:

Event	Trigger
`Enter`	ETH deposited to Passage
`EnterToken`	ERC-20 tokens deposited to Passage
`Transact`	Arbitrary execution requested via Transactor

System transactions execute last in the block, after all user-submitted transactions. Processing order within that group is:

Cross-chain transfers

Mon, 01 Jan 0001 00:00:00 +0000

Cross-chain transfers

Moving from Ethereum to Signet

Because Signet produces blocks at the same time as Ethereum, assets and data can move freely from Ethereum to Signet in the same block. If you send Ether to Signet, entering Signet has no time delay. Signet does not require a multi-minute wait like centrally sequenced rollups.

Troubleshooting

Mon, 01 Jan 0001 00:00:00 +0000

Common errors and debugging tips for Signet development. Select your language to see relevant code.

Key concepts

Mon, 01 Jan 0001 00:00:00 +0000

Key concepts

Signet is an EVM rollup that settles on Ethereum. Your application interacts with two chains simultaneously: Signet (the rollup) and Ethereum (the host chain). Deposits, swaps, and fills happen across both in the same block.

The building blocks

Passage moves assets from Ethereum into Signet. Deposits arrive in the same block.

Orders move assets from Signet back to Ethereum (or any chain). A filler delivers the output, and atomic settlement ensures both sides execute or neither does.

Application controlled execution

Mon, 01 Jan 0001 00:00:00 +0000

Application controlled execution

Same-Block Synchronization

Signet produces blocks in lockstep with Ethereum. Every Signet block corresponds to exactly one Ethereum block, with identical timestamps. This 1:1 coupling enables Signet to observe Ethereum state as it happens—not minutes later through an oracle, but in the same 12-second window.

Brand kit

Mon, 01 Jan 0001 00:00:00 +0000

Brand Kit

Logo

Use the mark alongside the wordmark “Signet” set in New York.

Signet Download SVG

Usage Guidelines

Maintain clear space equal to the mark’s height on all sides
Never distort, rotate, or add effects to the mark
On light backgrounds, use ink (#2D2926)
On dark backgrounds, use cream (#FAF7F2)

Color Palette

The Six Inks

Kin Gold

Accent, Keywords #D4A929

Matsu Pine

Success, Strings #5B8A5B

Shu Vermillion

Danger, Errors #B85450

Tsuki Moon

Info, Functions #4A8090

Fuji Wisteria

Secondary, Types #7868A0

Sakura Blossoms

Special, Escapes #C0707A

Paper Tones

Cream #FAF7F2

Warm #F5F1EA

Rule #E3DED5

Mist #ADA69C

Stone #7C756C

Graphite #4A4541

Ink #2D2926

Typography

Display New York Headlines, page titles, feature text

Body Iowan Old Style Long-form content, paragraphs, prose

Mono SF Mono Code, labels, technical content

Scale

Token	Size	Usage
micro	10px	Labels, eyebrows, badges
caption	12px	Captions, metadata
small	13px	Secondary text, buttons
body	15px	Body copy
h4	16px	Minor headings
h3	18px	Subsections
h2	22px	Sections
h1	28px	Page titles

Components

Buttons

Badges

Kin Matsu Shu Tsuki Fuji Sakura Default

Callouts

Note

Informational callout for helpful context.

How orders work

Mon, 01 Jan 0001 00:00:00 +0000

How orders work

An Order is Signet’s primitive for moving assets between chains. The user specifies what they’re giving up on Signet and what they want to receive on another chain. A filler delivers the output, a builder settles both sides atomically, and either the entire trade executes or nothing happens.

Orders power exits, swaps, and any cross-chain transfer that requires atomic settlement.

The lifecycle

The user creates an Order. They give up tokens on Signet and specify what they want on Ethereum (or any supported chain).
The Order is submitted to the transaction cache. On-chain orders are discovered via events; gasless orders are posted directly by your application.
Fillers evaluate the Order. They assess the spread between input and output and decide if the trade is profitable.
A filler commits. They construct a fill transaction for the destination chain and bundle it with the Signet-side settlement. A builder includes the bundle in a block proposal.
Atomic settlement. Either both sides execute or neither does.

The builder enforces atomicity. If the filler doesn’t deliver on the destination chain, the user’s tokens are never taken on Signet. There is no window where funds are at risk.

EVM behavior

Mon, 01 Jan 0001 00:00:00 +0000

EVM behavior

Signet targets full EVM compatibility.

This page describes the (very few) differences between Signet and Ethereum Mainnet EVM behavior.

USD Native Asset

The native asset on Signet is USD, not ETH. USD plays the same role that ETH does on Ethereum: it pays for gas, it’s what msg.value transfers, and it’s what address.balance returns. It has 18 decimals.

USD is minted on Signet when USDC or USDT is deposited through Passage. The node observes the deposit event on Ethereum and credits the recipient’s balance with native USD, normalizing decimals from 6 to 18. ETH and other supported tokens (WBTC) are bridged as ERC-20 tokens, not native USD. See System transactions for details on how deposits are processed.

Rebased Optimism

Tue, 10 Feb 2026 12:00:00 +0000

What you build when the chain does the work.

Optimistic Thinking

Fri, 06 Feb 2026 12:00:00 +0000

Rollups were supposed to be a bet on Ethereum. We’re making that bet.

Application Controlled Execution

Wed, 28 Jan 2026 12:00:00 +0000

How applications read L1 state and execute on Signet in the same block—without oracles or relayers.

Designing Signet Storage

Mon, 26 Jan 2026 00:00:00 +0000

Type-safe hot/cold storage architecture with strong consistency guarantees.

Optimizing MDBX Access in Rust

Mon, 26 Jan 2026 00:00:00 +0000

New Rust bindings for libmdbx, encoding database invariants in the type system.

Introducing Parmigiana

Wed, 14 Jan 2026 12:00:00 +0000

Our latest public testnet for Signet app builders and searchers.

Signet for Solvers

Thu, 18 Dec 2025 12:00:00 +0000

Same infrastructure, different game. How MEV searchers become Signet fillers.

USD-Native Gas

Wed, 03 Dec 2025 12:00:00 +0000

Gas in dollars. Balances in dollars. No conversion math.

Passage and Transactor

Wed, 12 Nov 2025 12:00:00 +0000

Two contracts. Three patterns. Every way to enter Signet from Ethereum.

Optimizing Discovery

Thu, 30 Oct 2025 16:00:00 -0700

Why we built one of the fastest documentation sites in crypto.

Instrumentation (for Rust Ethereum)

Thu, 16 Oct 2025 00:00:00 +0000

Moving beyond logging to distributed tracing for production-ready Ethereum infrastructure.

Introducing Pecorino

Mon, 28 Jul 2025 12:00:00 +0000

A public testnet that works where developers need it most.

Contracts That Read The Future

Tue, 15 Jul 2025 12:00:00 +0000

Flash loans without pools. Payment gates without msg.value. Exits without waiting.

Block Building Without Auctions

Wed, 25 Jun 2025 12:00:00 +0000

Why predictable rotation beats competitive bidding.

Synchronous Finality

Thu, 15 May 2025 12:00:00 +0000

Both chains in the same block, or nothing happens.

Clone and build

Mon, 01 Jan 0001 00:00:00 +0000

Clone and Build the Signet Builder

The Builder simulates bundles and transactions to create valid rollup blocks and submits them to Ethereum.

Prerequisites

Rust ≥ 1.85
Git
AWS CLI

Recommended System Specs

CPU: 0.5 vCPU (minimum 0.1 vCPU)
Memory: 512MB (minimum 256MB)
Clock speed: 2.8GHz+ (builder prefers clock speed over core count)

Clone the Repository

 bash
 
 
git clone https://github.com/init4tech/builder
cd builder

Build Options

Local Build

bash

cargo build --release

The compiled binary will be available at target/release/builder.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

Key Features for Builders

As a Signet Block Builder, you construct blocks by selecting transactions and bundles, then submit those blocks to Ethereum.

Direct Sequencer Access: Work directly with the Signet sequencer in a round-robin slot system, unlike traditional PBS auctions.
Capture MEV and Sequencer Fees: Directly extract value from transactions within your blocks.
Fair Block Production: Round-robin sequencing ensures equitable opportunities for all builders.

Quickstart

To get started as a block builder:

Signet – Same Block on Signet

Authentication

Authentication

Overview

OAuth Identity Provider Reference

Havarti

Authenticating Using curl

Build from source

Build From Source

Installation

Environment variables

Environment Variables

Fetching transactions

Getting transactions and bundles

Getting Transactions and Bundles

Transaction cache basics:

API Endpoints

Get Transactions

Bundle guarantees

Bundle Guarantees

Bundle Guarantees

Docker

Docker

Installation

Signed orders

Signed Orders

Constructing Token Transfers

Compiled binaries

Compiled Binaries

Installation

Filler

Filler

Setup

Architecture

Environment variables

Environment Variables

Getting a sequencer signature

Getting a Sequencer Signature

Slot Timing

Parmigiana quickstart

Parmigiana quickstart

Chain configuration

Chain Configuration

Getting started

Submitting a block to Ethereum

Submitting a Block to Ethereum

Code Flows

Building with Orders

The Filler Economy

How Signet Works

Enter Signet

Execute from Ethereum

Overview

Default Chain

FAQ

FAQ

Simplifying the rollup

Simplifying the rollup

Bundles

Exit Signet

Order data model

Glossary

Glossary

No proofs or state roots

No proofs or state roots

No proving system

Permissioned roles

Permissioned Roles

Core Roles

Sequencer Admin

Sequencer

Simple sequencing

Simple sequencing

Centralization of Sequencing

Simulating bundles

Swap within Signet

System transactions

System transactions

Cross-chain transfers

Cross-chain transfers

Authenticating Using `curl`