# Deposit Without the App

> Enter a leveraged position by calling the Facility directly — from Etherscan, a wallet that accepts raw calldata, or Foundry's cast. Find and verify an open deposit intent, approve USDC, deposit, and claim Position Manager shares once the intent resolves.



You don't need the 3F app to enter a position. Every step is a plain contract call, so you can make it from Etherscan, from any wallet that accepts raw calldata (Safe, Fireblocks, Fordefi, …), or from the command line with Foundry's `cast`. Under the hood this is the [deposit flow](/protocol/flows/deposit/): you deposit USDC into a Facility **intent**, receive ERC-6909 LP tokens 1:1, and once the intent is resolved you burn them to claim your Position Manager shares.

The whole process takes four transactions spread over the life of the intent:

1. `approve` — let the Facility pull your USDC
2. `deposit` — send USDC into the intent
3. *(wait for the intent to resolve)*
4. `claim` — burn your LP tokens and receive the Position Manager shares

To exit a position the same way, see [Redeem Without the App](/protocol/guides/manual-redeem/).

## Before You Start

You need:

- **A wallet that can sign transactions** on Ethereum mainnet, holding the USDC you want to deposit and some ETH for gas.
- **An allowed address.** LP tokens and Position Manager shares are governed by the Position Manager's [TransferGuard](/protocol/transfer-guard/). Your address must be onboarded with 3F, otherwise `deposit` reverts with `TransferBlocked`.
- **An intent ID confirmed by the 3F team** — see [step 1](#1-find-an-open-intent).

| Contract | Address |
| --- | --- |
| Facility | [`0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`](https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F) |
| USDC | [`0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`](https://etherscan.io/address/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) |
| Position Managers | One per asset and leverage tier — see [Deployments](/protocol/deployments/) |

## How to Send the Calls

Each step below shows its call in three formats. Pick one tab and every call on the page — and on the redemption guide — switches with it.

- **Etherscan** — no tooling needed. The Facility is a proxy, so its functions live under **Contract → Read as Proxy** and **Contract → Write as Proxy**. Click **Connect Wallet** before calling a write function; the links open the right function directly.
- **Calldata** — the raw `to` and `data` of each call, for wallets that take them directly: a custom transaction in Safe's Transaction Builder, a contract call in Fireblocks or Fordefi, or your own scripts. Writes send 0 ETH; reads are `eth_call`s.
- **cast** — commands for [Foundry](https://getfoundry.sh/)'s `cast`. Set `ETH_RPC_URL` to a mainnet RPC first. Write commands use `--interactive`, which prompts for a private key; replace it with `--account <name>` for a Foundry keystore, or `--ledger` / `--trezor` for a hardware wallet.

![The Facility's Write as Proxy tab on Etherscan, with the Connect Wallet button](/images/guides/etherscan/facility-write-tab.webp)

:::caution[Amounts are raw integers]
Contracts take token amounts in the token's smallest unit. USDC has **6 decimals**, so 10,000 USDC is `10000000000` (10,000 × 10⁶). The builder below does the conversion for you; on Etherscan, the **Scale** dropdown next to each amount field can also append the zeros.
:::

:::caution[Use the right `approve`]
The Facility has its own `approve` function, which is the ERC-6909 approval for LP tokens. It is **not** the one you need — the USDC approval is made on the USDC contract.
:::

## Fill In Your Values

Enter your values once and every call below is filled in for you, in all three formats.

The calls below use these placeholders — replace them with your own values:

- `<intent-id>` — the intent ID from step 1
- `<amount>` — the amount in USDC, in 6-decimal units
- `<your-address>` — your address

## 1. Find an Open Intent

Deposits go into a specific intent, identified by a numeric ID. The 3F team creates deposit intents for each Position Manager. Several are often open at once (including [in-kind](/protocol/flows/in-kind-deposit/) intents that take the wrapped asset instead of USDC), so you need the ID of the one meant for you.

There are two ways to find it:

- **Ask the 3F team** for the intent ID to use.
- **Use the 3F LP API.** `GET https://lp.3f.xyz/v1/intents/{asset}?state=created` lists the intents that are still open for an asset. Keep the items with `"type": "deposit"`; the intent ID is `onChainId`. Add `&vault=<position manager address>` to narrow the list to one leverage tier. The full API reference is at [lp.3f.xyz/docs](https://lp.3f.xyz/docs).

| Asset | `{asset}` slug |
| --- | --- |
| Bitwise USCC | `superstate-uscc` |
| Janus Henderson JAAA | `centrifuge-jaaa` |
| Midas mGLO | `midas-mglo` |
| FalconX | `pareto-falconx` |

You can also index `IntentCreated` events on the Facility yourself.

:::danger[Confirm the intent with 3F]
Whichever way you find an intent, confirm with the 3F team that it is the right one for your deposit before sending funds. The facilitator can close an intent's deposit window early, and caps change as intents fill.
:::

## 2. Verify the Intent

Read the intent's configuration with `getIntent`:

Call `getIntent(uint256)` (selector `0x906e277b`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Read as Proxy → `getIntent` (#6): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#readContract#F6

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |

![getIntent result on Etherscan for a USDC deposit intent into FALCONX-5X](/images/guides/etherscan/deposit-get-intent.webp)

```sh
cast call 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "getIntent(uint256)(((address,bool),(address,bool),uint256,address,uint40,uint8,bool),address,address,bool)" <intent-id> \
  --rpc-url "$ETH_RPC_URL"
```

`cast` prints the same fields as a tuple — the intent's properties, then `fund`, `request` and `resolved`:

```
((0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, false), (0x7495A9331b45908E26bE32D84114f8309520da93, true), 32000000000 [3.2e10], 0x7495A9331b45908E26bE32D84114f8309520da93, 1795012448 [1.795e9], 1, true)
0x0000000000000000000000000000000000000000
0x0000000000000000000000000000000000000000
false
```

The properties tuple is, in order: `(depositAsset.asset, depositAsset.isPositionManager)`, `(targetAsset.asset, targetAsset.isPositionManager)`, `depositCap`, `guardKey`, `resolveStart`, `quorum`, `transferableIntent`.

Check every field against the table below. If anything does not match, do not deposit — contact the 3F team.

| Field | Expected for a deposit intent |
| --- | --- |
| `depositAsset.asset` | USDC — `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` (the Position Manager's debt asset) |
| `depositAsset.isPositionManager` | `false` |
| `targetAsset.asset` | The Position Manager you want to enter. Cross-check the address on [Deployments](/protocol/deployments/) |
| `targetAsset.isPositionManager` | `true` |
| `depositCap` | Leaves room for your deposit — see [the cap check](#check-the-remaining-cap) below |
| `guardKey` | The same address as `targetAsset.asset` |
| `resolveStart` | **In the future**, with a comfortable margin. It is a Unix timestamp in seconds — deposits close at this time |
| `quorum` | **At least `1`** — the number of guardian signatures required before the facilitator can bind a Fund or Request to the intent or swap its balances |
| `transferableIntent` | Informational — whether your LP tokens can be transferred to another address |
| `resolved` | **`false`** |

In the example above, intent `12195` takes USDC and targets FALCONX-5X (`0x7495…da93`), accepts up to 32,000 USDC (`32000000000`), closes deposits at `1795012448` (2026-11-18 14:34 UTC), requires one guardian signature and is not resolved — a valid deposit intent at the time of the screenshot.

:::tip
To confirm USDC is the Position Manager's debt asset, call `assets()` on the Position Manager (#3 under **Read as Proxy** on Etherscan) — it returns `(collateral, debt)`. If the intent's deposit asset is the collateral (a wrapped asset such as wFalconX) rather than the debt asset, it is an [in-kind deposit](/protocol/flows/in-kind-deposit/) intent, not a USDC one.
:::

### Check the Remaining Cap

A deposit reverts if it would push the intent's total deposits above `depositCap`. `totalSupply` returns the amount already deposited:

Call `totalSupply(uint256)` (selector `0xbd85b039`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Read as Proxy → `totalSupply` (#19): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#readContract#F19

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |

![totalSupply on Etherscan for the deposit intent](/images/guides/etherscan/deposit-total-supply.webp)

```sh
cast call 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "totalSupply(uint256)(uint256)" <intent-id> \
  --rpc-url "$ETH_RPC_URL"
```

The most you can deposit is `depositCap − totalSupply`, both in USDC's 6-decimal units. In the example: `32000000000 − 0`, so up to 32,000 USDC.

## 3. Approve USDC

Allow the Facility to pull your deposit by calling `approve` on USDC, with the Facility as spender and your deposit amount as value:

Call `approve(address,uint256)` (selector `0x095ea7b3`) on the USDC, `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`.

- **Etherscan:** Write as Proxy → `approve` (#1): https://etherscan.io/address/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48#writeProxyContract#F1

| Field | Value |
| --- | --- |
| spender (address) | `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F` |
| value (uint256) | `<amount>` |

![USDC approve on Etherscan with the Facility as spender](/images/guides/etherscan/deposit-approve.webp)

```sh
cast send 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 \
  "approve(address,uint256)" \
  0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F <amount> \
  --rpc-url "$ETH_RPC_URL" --interactive
```

Approving the exact amount, rather than an unlimited allowance, keeps the Facility from being able to pull more USDC than you intend.

## 4. Deposit

Call `deposit` on the Facility with the intent ID and the amount you approved:

Call `deposit(uint256,uint256)` (selector `0xe2bbb158`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Write as Proxy → `deposit` (#10): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#writeContract#F10

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |
| amount (uint256) | `<amount>` |

![deposit into intent 12195 on Etherscan](/images/guides/etherscan/deposit-deposit.webp)

```sh
cast send 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "deposit(uint256,uint256)" \
  <intent-id> <amount> \
  --rpc-url "$ETH_RPC_URL" --interactive
```

The Facility pulls your USDC and mints you the same amount of LP tokens for that intent. Keep a note of the amount — it is what you claim with later. You can check your LP balance at any time:

Call `balanceOf(address,uint256)` (selector `0x00fdd58e`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Read as Proxy → `balanceOf` (#2): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#readContract#F2

| Field | Value |
| --- | --- |
| owner (address) | `<your-address>` |
| id (uint256) | `<intent-id>` |

```sh
cast call 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "balanceOf(address,uint256)(uint256)" <your-address> <intent-id> \
  --rpc-url "$ETH_RPC_URL"
```

:::tip[Simulate first]
Simulate the deposit before sending it: Etherscan has a **Simulate** button, Safe and most custody wallets simulate automatically, and with `cast` you can run the same arguments through `cast call --from <your address>` (decode a revert with `cast decode-error`). The usual failures are `NotDepositing` (the deposit window has closed), `DepositCapExceeded` (the cap is full), `TransferBlocked` (the TransferGuard does not allow your address), or an allowance error (the approval is missing or too small).
:::

## 5. Wait for the Intent to Resolve

Deposits close at `resolveStart`, or earlier if the facilitator locks the intent. The facilitator then executes the strategy: it takes a bridge loan, subscribes to the fund, waits for settlement, opens the leveraged position in the Position Manager and repays the bridge loan (see the [deposit flow](/protocol/flows/deposit/)). Settlement can take from days to weeks depending on the fund.

Until deposits close you can still back out. `withdraw` burns your LP tokens and returns your USDC 1:1:

Call `withdraw(uint256,address,address,uint256)` (selector `0xa318c1a4`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Write as Proxy → `withdraw` (#36): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#writeContract#F36

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |
| from (address) | `<your-address>` |
| receiver (address) | `<your-address>` |
| amount (uint256) | `<amount>` |

```sh
cast send 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "withdraw(uint256,address,address,uint256)" \
  <intent-id> <your-address> <your-address> <amount> \
  --rpc-url "$ETH_RPC_URL" --interactive
```

Once deposits close, your funds stay committed until resolution. To check progress, read [`getIntent`](#2-verify-the-intent) again — the intent is ready to claim when `resolved` is `true`.

## 6. Claim Your Position Manager Shares

Once the intent is resolved, a claim pays out your pro-rata share of everything the intent holds — the Position Manager shares, plus any USDC that was not deployed. To preview what the intent holds:

Call `intentBalances(uint256)` (selector `0xa43bb77d`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Read as Proxy → `intentBalances` (#10): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#readContract#F10

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |

```sh
cast call 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "intentBalances(uint256)(address[],uint256[])" <intent-id> \
  --rpc-url "$ETH_RPC_URL"
```

Then call `claim` with your address as both `from` (the owner of the LP tokens) and `receiver` (where the shares are sent), and the number of LP tokens to burn as `shares` — the total amount you deposited, in the same 6-decimal units:

Call `claim(uint256,address,address,uint256)` (selector `0xd6e3413e`) on the Facility, `0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F`.

- **Etherscan:** Write as Proxy → `claim` (#5): https://etherscan.io/address/0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F#writeContract#F5

| Field | Value |
| --- | --- |
| id (uint256) | `<intent-id>` |
| from (address) | `<your-address>` |
| receiver (address) | `<your-address>` |
| shares (uint256) | `<amount>` |

![claim for intent 12195 on Etherscan](/images/guides/etherscan/deposit-claim.webp)

```sh
cast send 0x4e013ca8fF612a58F53C822904cDD0eC538a4A4F \
  "claim(uint256,address,address,uint256)" \
  <intent-id> <your-address> <your-address> <amount> \
  --rpc-url "$ETH_RPC_URL" --interactive
```

The Facility burns your LP tokens and sends you the proceeds. You can also claim in several parts by burning fewer LP tokens each time. The Position Manager shares then appear in your wallet as a regular ERC-20 token (e.g. `FALCONX-5X`, 18 decimals).