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

# Quickstart: Deposit into an Earn vault

> Discover available vaults and deposit USDC into one on Arc Testnet

Earn yield on your USDC by depositing it into a Morpho vault on Arc Testnet.
This quickstart uses Circle Wallets, but you can use any compatible
[adapter setup](/app-kit/tutorials/adapter-setups).

## Prerequisites

Before you begin, ensure that you've:

* Installed [Node.js v22+](https://nodejs.org/).
* Obtained an
  [API key](https://developers.circle.com/api-reference/keys#creating-an-api-key-for-developer-services)
  and
  [entity secret](https://developers.circle.com/wallets/dev-controlled/register-entity-secret)
  from the
  [Circle Console](https://developers.circle.com/w3s/circle-developer-account).
* Created a developer-controlled wallet on Arc Testnet using the Circle Console.
* Funded your Arc Testnet wallet with testnet USDC from the
  [Circle Faucet](https://faucet.circle.com/).

<Note>
  Earn operations work without an API key. For higher rate limits, pass an
  optional [API key](/app-kit/earn#api-key) as `apiKey` in the operation config.
  Keep the API key server-side. The App Kit SDK rejects an API key passed from a
  browser context.

  <Accordion title="Example: passing an API key">
    ```typescript TypeScript theme={null}
    const result = await kit.earn.deposit({
      from: { adapter, chain: "Arc_Testnet" },
      vaultAddress: "0x...",
      amount: "10.00",
      config: { apiKey: process.env.API_KEY as string },
    });
    ```
  </Accordion>
</Note>

## Step 1. Set up the project

### 1.1. Create the project and install dependencies

Create a new directory and install the App Kit SDK with the Circle Wallets
adapter and supporting tools:

```bash Shell theme={null}
# Set up your directory and initialize a Node.js project
mkdir app-kit-earn-deposit-circle-wallets
cd app-kit-earn-deposit-circle-wallets
npm init -y
npm pkg set type=module

# Set up run scripts
npm pkg set scripts.explore-vaults="tsx --env-file=.env explore-vaults.ts"
npm pkg set scripts.deposit="tsx --env-file=.env deposit.ts"

# Install runtime dependencies
npm install @circle-fin/app-kit @circle-fin/adapter-circle-wallets tsx

# Install dev dependencies
npm install --save-dev typescript @types/node
```

<Tip>
  Only need Earn and want a lighter install than the full App Kit? Install the
  standalone package instead: `@circle-fin/earn-kit`
</Tip>

### 1.2. Configure TypeScript (optional)

<Info>
  This step is optional. It helps prevent missing types in your IDE or editor.
</Info>

Create a `tsconfig.json` file configured for ESM and Node:

```bash Shell theme={null}
cat <<'EOF' > tsconfig.json
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "types": ["node"]
  }
}
EOF
```

### 1.3. Set environment variables

Create an `.env` file in the project directory:

```bash Shell theme={null}
touch .env
```

Add your credentials. Replace `YOUR_API_KEY` with your Circle Developer API key,
`YOUR_ENTITY_SECRET` with your entity secret:

```text .env theme={null}
CIRCLE_API_KEY=YOUR_API_KEY
CIRCLE_ENTITY_SECRET=YOUR_ENTITY_SECRET
```

<Tip>
  Edit `.env` files in your IDE or editor so credentials are not leaked to your
  shell history.
</Tip>

## Step 2. Discover available vaults

`kit.earn.exploreVaults` returns the vaults available on a chain along with each
vault's address, current APY, fees, and status. Use it to pick a vault to
deposit into.

### 2.1. Create the discovery script

Create an `explore-vaults.ts` file:

```typescript explore-vaults.ts theme={null}
import { AppKit } from "@circle-fin/app-kit";

const kit = new AppKit();

async function main() {
  const { vaults, pagination } = await kit.earn.exploreVaults({
    chain: "Arc_Testnet",
    sortBy: "apy",
  });

  console.log(`Found ${pagination.totalCount} vaults`);
  console.dir(vaults, { depth: null, colors: true });
}

void main();
```

<Tip>
  `kit.earn.exploreVaults` accepts filter, sort, and pagination parameters such as
  `protocol`, `asset`, `minApy`, `minTvl`, `sortBy`, `page`, and `pageSize`. For
  lazy iteration across all pages, use `kit.earn.exploreVaultsIterator`.
</Tip>

### 2.2. Run the discovery script

In your terminal, run:

```bash Shell theme={null}
npm run explore-vaults
```

You'll see output like:

```bash Shell theme={null}
Found 4 vaults
[
  {
    vaultAddress: '0x...',
    chain: 'Arc_Testnet',
    name: 'Steakhouse USDC',
    protocol: 'MORPHO',
    asset: 'USDC',
    assetAddress: "0x...",
    currentApy: 0.042,
    nativeApy: 0,
    vaultFee: 0,
    rewards: [],
    collateral: [],
    status: "active",
    circleGuarded: false,
    totalDeposits: "0.0",
    liquidity: "1000000.0",
  },
  ...
]
```

<Note>
  Only deposit into a vault with `status: 'active'`. A `'low_liquidity'` vault may
  not have enough liquidity for withdrawals.
</Note>

`kit.earn.exploreVaults` returns all Morpho vaults on the blockchain. No
allowlist is applied, so integrators choose any active vault to deposit into.
Crosschain deposits are an exception: gas-sponsored crosschain routes use a
manually allowlisted set of destination vaults.

### 2.3. Pick a vault

Choose a vault from the output and copy its `vaultAddress`. You'll use it in the
next step.

## Step 3. Deposit USDC

<Note>
  If your wallet is on a different blockchain than the vault, see
  [Deposit crosschain into an Earn vault](/app-kit/tutorials/earn/crosschain-deposit)
  instead.
</Note>

### 3.1. Create the deposit script

Create a `deposit.ts` file. Replace `YOUR_SELECTED_VAULT_ADDRESS` with the vault
address you copied in the previous step and `YOUR_CIRCLE_WALLET_ADDRESS` with
the address of your Circle Wallets wallet. This script deposits 10.00 USDC into
the vault:

<Note>
  Pass `amount` as a positive decimal string (for example `"10.00"`). Zero and
  negative values are rejected. For USDC and EURC, use at most 6 decimal places.
  Leading zeros and leading-dot forms (for example `"00.5"` or `".5"`) are
  rejected.
</Note>

```typescript deposit.ts theme={null}
import { AppKit } from "@circle-fin/app-kit";
import { createCircleWalletsAdapter } from "@circle-fin/adapter-circle-wallets";

const kit = new AppKit();
const amount = "10.00";
const vaultAddress = "YOUR_SELECTED_VAULT_ADDRESS";

const adapter = createCircleWalletsAdapter({
  apiKey: process.env.CIRCLE_API_KEY!,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
});

async function main() {
  const result = await kit.earn.deposit({
    from: {
      adapter,
      chain: "Arc_Testnet",
      address: "YOUR_CIRCLE_WALLET_ADDRESS",
    },
    vaultAddress,
    amount,
  });

  console.dir(result, { depth: null, colors: true });
}

void main();
```

<Tip>
  Preview the expected outcome of a deposit before submitting with
  [`kit.earn.getDepositQuote`](/app-kit/tutorials/earn/preview-operations#preview-a-deposit).
</Tip>

### 3.2. Run the deposit script

In your terminal, run:

```bash Shell theme={null}
npm run deposit
```

When the script completes, you'll see output like:

```bash Shell theme={null}
{
  kind: "same-chain",
  txHash: "0x...",
  explorerUrl: "https://explorer.testnet.arc.io/tx/0x...",
  vaultAddress: "0x...",
  amount: "10",
}
```

Use the `txHash` to verify the transaction on the Arc Testnet block explorer. To
confirm the vault shares credited to your wallet, see
[Check your Earn position](/app-kit/tutorials/earn/check-position). When you're
ready to redeem, see
[Withdraw from an Earn vault](/app-kit/quickstarts/earn-withdraw).