---
title: "System transactions"
url: "/docs/build-on-signet/system-transactions/index.md"
description: "How events on Ethereum produce transactions on Signet, including asset minting and host-originated execution."
---
# System transactions

Transactions on Signet can originate from Ethereum. Signet's consensus rules
specify that certain events emitted by the
[Passage](/docs/build-on-signet/transfers/enter-signet/index.md) and
[Transactor](/docs/build-on-signet/advanced/execute-from-ethereum/index.md)
contracts on the host chain produce 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. Host events are processed in the following order:

1. `Enter` — all ETH deposit mints
2. `EnterToken` — all token deposit mints, in host event order
3. `Transact` — all host-originated execution

Because `EnterToken` events are processed in host event order, native asset
mints (USD) and non-native token mints (e.g. WBTC) are interleaved rather
than grouped by type.

A single host transaction can produce multiple system transactions. For
example, the Transactor's `enterTransact` function emits both an `Enter` event
and a `Transact` event, producing two system transactions in the same block.

## Magic signature

System transactions are not signed by a private key. The signature field
carries a **magic signature** — a value with the same RLP structure as a
standard Ethereum signature (`r`, `s`, `y_parity`) but which is not a valid
ECDSA signature. It encodes three fields:

- **Event type**: `Enter`, `EnterToken`, or `Transact`
- **Transaction hash**: the host-chain transaction that emitted the event
- **Event index**: position of the event within the transaction's logs

The `s` value of the signature begins with the sentinel `0xffeeddcc`, which
exceeds the secp256k1 curve order. This makes it impossible to confuse a
magic signature with a real ECDSA signature on any EIP-2 chain.

For `Transact` events, the magic signature also encodes the sender address and
whether [address aliasing](/docs/learn-about-signet/evm-behavior/index.md#address-aliasing)
was applied.

See the
[`MagicSig` documentation](https://docs.rs/signet-types/latest/signet_types/struct.MagicSig.html)
for the full wire format specification.

## Native asset mints

When USDC or USDT is deposited through Passage (`EnterToken` event), the
recipient's native [USD](/docs/learn-about-signet/evm-behavior/index.md#usd-native-asset)
balance is increased directly. This is not an EVM transaction — no contract
code is executed.

Amounts are normalized from the host token's decimals to 18. For example,
1 USDC (`10**6` on Ethereum) becomes `10**18` wei of native USD on Signet.

The transaction emits a `MintNative` log from `MINTER_ADDRESS`
(`0x00000000000000000000746f6b656e61646d696e`). The `txHash` and `logIndex`
fields reference the originating host-chain event, allowing indexers to
connect rollup-side mints to their host-chain deposits.

```solidity
event MintNative(
    bytes32 indexed txHash,
    uint64 indexed logIndex,
    address indexed recipient,
    uint256 amount
);
```

## Token mints

ETH deposits (`Enter`) and non-USD token deposits (`EnterToken`) produce a
system transaction that calls `mint(recipient, amount)` on the corresponding
rollup-side ERC-20 contract.

| Host asset | Rollup token |
| ---------- | ------------ |
| ETH        | WETH         |
| WBTC       | WBTC         |

These transactions run from `MINTER_ADDRESS` with zero gas cost.

**Transaction properties:**

- `from`: `MINTER_ADDRESS`
- `to`: the rollup token contract
- `value`: 0
- `nonce`: next nonce for `MINTER_ADDRESS`
- `input`: ABI-encoded `mint(address recipient, uint256 amount)`
- `max_fee_per_gas`: 0
- `max_priority_fee_per_gas`: 0

The transaction emits a `MintToken` log from `MINTER_ADDRESS`. As with
`MintNative`, the `txHash` and `logIndex` fields reference the originating
host-chain event for indexer correlation.

```solidity
event MintToken(
    bytes32 indexed txHash,
    uint64 indexed logIndex,
    address indexed recipient,
    address hostToken,
    uint256 amount
);
```

## Transact

When the host
[Transactor](/docs/build-on-signet/advanced/execute-from-ethereum/index.md)
emits a `Transact` event, it triggers a system transaction on Signet from the
caller's address. This allows Ethereum contracts to own assets on Signet and
trigger execution there, using their Ethereum address as the sender.

**Transaction properties:**

- `from`: the host-chain `msg.sender`, [aliased](/docs/learn-about-signet/evm-behavior/index.md#address-aliasing) if the sender is a smart contract
- `to`: as specified in the event
- `value`: as specified in the event (USD wei)
- `input`: as specified in the event
- `nonce`: next nonce for the sender's Signet account
- `gas_limit`: as specified in the event
- `max_fee_per_gas`: as specified in the event
- `max_priority_fee_per_gas`: 0

> **Inclusion guarantee:** If the `Transact` event was emitted on the host chain, the system transaction
is guaranteed to be included on Signet. Inclusion does not guarantee the inner
call succeeds. Contract creation via Transactor is not supported.