---
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. When the Signet node
observes specific events from the
[Passage](/docs/build-on-signet/transfers/enter-signet/index.md) or
[Transactor](/docs/build-on-signet/advanced/execute-from-ethereum/index.md)
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:

1. `Enter`
2. `EnterToken`
3. `Transact`

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.

## MagicSig

System transactions are not signed by a private key. The signature field
carries a **MagicSig** with 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
MagicSig with a real ECDSA signature on any EIP-2 chain.

For `Transact` events, the MagicSig 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 node
mints native [USD](/docs/learn-about-signet/evm-behavior/index.md#usd-native-asset)
directly to the recipient's balance. This is not an EVM transaction. The node
increases the account balance directly, without executing contract code.

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 node emits a `MintNative` system log from `MINTER_ADDRESS`:

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

`MINTER_ADDRESS` is `0x00000000000000000000746f6b656e61646d696e`.

## Token mints

ETH deposits (`Enter`) and non-USD token deposits (`EnterToken`) produce a
token mint transaction. The node 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 node emits a `MintToken` system log from `MINTER_ADDRESS`:

```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, the node creates a 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.