> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aultblockchain.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Transfer Assets

A token on Ault EVM is an ERC20 balance. Ault DEX settles on Ault Core against native
denominations. Moving between the two is a required step before a first trade, whether the token was
bridged in or issued on Ault.

```
Ault EVM (ERC20)  --transferToCore-->  Ault Core (native denom)  -->  Ault DEX
Ault EVM (ERC20)  <--transferToEVM--   Ault Core (native denom)
```

> [!NOTE]
>
> This is a representation change on one chain, not a bridge. No external relayer is involved and there
> is no bridge delay.

## Which Direction

| Goal | Direction |
| - | - |
| Place orders on Ault DEX | EVM to Core |
| Use proceeds in a Solidity contract | Core to EVM |
| Bridge out of Ault | Core to EVM, then bridge |

## Look Up the Token Pair

```bash theme={null}
# every registered pair
curl "https://main-api.cloud.aultblockchain.xyz/ault/tokenregistry/v1/token_pairs"

# one token, by ERC20 address or erc20:0x... denom
curl "https://main-api.cloud.aultblockchain.xyz/ault/tokenregistry/v1/token_pair/0x..."
```

`GET /api/v1/currencies` reports the same assets in exchange form. See
[Markets & Currencies](https://docs.aultblockchain.com/dex-api/rest/markets-and-currencies.md).

## Convert

Both directions are transactions on the Token Registry precompile:

| Direction | Method |
| - | - |
| EVM to Core | `transferToCore(address,uint256,address)` |
| Core to EVM | `transferToEVM(address,uint256,address)` |

Signatures, `cast` examples, the ABI, and the two-stage settlement model are documented on the
[Token Registry precompile](https://docs.aultblockchain.com/developer-guide/precompile/tokenregistry.md).

### Amounts and Decimals

The two sides do not use the same scale.

| Side | Decimals |
| - | - |
| Ault Core | Always 18, for every token |
| Ault EVM | Whatever the ERC20 contract declares |

USDC.e is the case to keep in mind: a 6-decimal contract on EVM, held with 18 decimals on Core. One
USDC.e is `1000000` in EVM contract units and `1000000000000000000` on Core.

Read the contract value as `erc20_decimals`:

```bash theme={null}
curl "https://main-api.cloud.aultblockchain.xyz/ault/tokenregistry/v1/token_pair/0x..."
```

```json theme={null}
{
  "token_pair": {
    "erc20_address": "0x5b58c971AF1EE0Fe5D5f772d68Ab3829262DFD2b",
    "denom": "erc20:0x5b58c971AF1EE0Fe5D5f772d68Ab3829262DFD2b",
    "erc20_decimals": 6,
    "enabled": true
  }
}
```

> [!WARNING]
>
> `erc20_decimals` is the EVM side only. Spot balance and fill responses normalize Core
> 18-decimal amounts into human-unit strings; an ERC20 call instead expects integers in the token
> contract's decimal scale. Other API families expose raw units where documented. Track the asset,
> interface and scale before constructing a transfer.

> [!WARNING]
>
> The precompile returns after validating and queueing the conversion, not after moving the balance. Do
> not read a balance back in the same call and expect it to reflect the transfer.

## Withdrawal Limits

Moving a token from Core to EVM is capped. Each token has an hourly and a daily ceiling, and a
transfer that would exceed the remaining capacity fails until the window rolls over, so a large
withdrawal may need to be split.

```bash theme={null}
curl "https://main-api.cloud.aultblockchain.xyz/ault/tokenregistry/v1/transfer_limit/0x..."
```

The response carries the ceilings under `config` and the capacity left in the current windows under
`state`, as `hourly_remaining` and `daily_remaining`. Both are 18-decimal amounts, and they apply to
the token as a whole rather than per account.

> [!NOTE]
>
> This is an outflow limit. `transferToCore`, the direction you use to fund an account before trading,
> is not capped. Check the remaining capacity only when moving funds out to EVM.

## Verify

| Side | Check |
| - | - |
| Ault Core | [Balances](https://docs.aultblockchain.com/dex-api/rest/balances.md), or `GET /cosmos/bank/v1beta1/balances/{address}` |
| Ault EVM | `eth_call` to `balanceOf`, see [JSON-RPC API](https://docs.aultblockchain.com/developer-guide/json-rpc-api.md) |

More query paths are listed in [Chain Queries](https://docs.aultblockchain.com/dex-api/advanced/chain-queries.md).

## Common Problems

| Symptom | Cause |
| - | - |
| Token not registered | The asset has no registered pair. Only registry assets convert |
| Transfers disabled | Module-wide transfers or that specific pair are not enabled |
| Amount rejected | The value was given in display units instead of base units |
| Transfer exceeds capacity | Core to EVM only. The token's hourly or daily ceiling is used up. Retry after the window rolls over, or split the transfer |
| Funds missing after trading | Proceeds are on Core. Convert before looking on EVM |

> [!WARNING]
>
> Gas is paid in `AULT` on the layer you submit from. Converting an entire `AULT` balance to the other
> side can leave the account unable to pay for the transaction back. Keep a gas reserve on both sides.

For bringing assets into Ault in the first place, see
[Bring Assets to Ault](https://docs.aultblockchain.com/user-guide/bring-assets-to-ault.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.