Quickstart

This guide walks you through creating an account and earning yield on Compound — the most common integration flow. By the end, you’ll have a working sub-account earning USDC yield on Base.

Prerequisites

A Legend Prime Account with a query key (contact us to get set up)
Node.js 18+ or Python 3.9+

1. Install the SDK

npm install legend-prime viem

pip install legend-prime eth-account

# Cargo.toml
[dependencies]
legend-client = "0.1"
legend-signer = "0.1"
tokio = { version = "1", features = ["full"] }

2. Generate a signer key

Each sub-account needs a signer — an Ethereum key that authorizes fund movements. For this quickstart, we’ll generate a fresh EOA key:

import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";

const privateKey = generatePrivateKey();
const signer = privateKeyToAccount(privateKey);

console.log("Private key:", privateKey);       // Save this securely!
console.log("Signer address:", signer.address);

from eth_account import Account

signer = Account.create()

print(f"Private key: {signer.key.hex()}")    # Save this securely!
print(f"Signer address: {signer.address}")

use legend_signer::{FileSigner, Signer};
use std::path::Path;

let signer = FileSigner::generate(Path::new("key.pem"))?;
println!("Public key: {}", signer.public_key_hex());

Save the private key. You’ll need it to sign every transaction for this account. If you lose it, funds in the account can’t be moved.

3. Initialize the client

import { LegendPrime } from "legend-prime";

const client = new LegendPrime({
  queryKey: process.env.LEGEND_QUERY_KEY,
});

from legend_prime import LegendPrime

client = LegendPrime(
    query_key=os.environ["LEGEND_QUERY_KEY"],
)

use legend_client::{LegendPrime, Config};

let client = LegendPrime::new(Config {
    query_key: std::env::var("LEGEND_QUERY_KEY").unwrap(),
    base_url: None,
});

4. Create a sub-account

Pass the signer’s address to create a sub-account. Legend creates a Quark Wallet — an on-chain smart wallet — for the account.

curl -X POST https://prime-api.legend.xyz/accounts \
  -H "Authorization: Bearer $LEGEND_QUERY_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "signer_type": "eoa",
    "signer_address": "'$SIGNER_ADDRESS'"
  }'

const account = await client.accounts.create({
  signerType: "eoa",
  signerAddress: signer.address,
});

console.log(account.account_id);           // "acc_2o0yiljtp378"
console.log(account.legend_wallet_address); // "0xc408...642f"

account = await client.accounts.create(
    signer_type="eoa",
    signer_address=signer.address,
)

print(account["account_id"])           # "acc_2o0yiljtp378"
print(account["legend_wallet_address"]) # "0xc408...642f"

use legend_client::CreateAccountParams;

let account = client.accounts.create(&CreateAccountParams {
    signer_type: "eoa".into(),
    ethereum_signer_address: Some(signer_address.into()),
    ..Default::default()
}).await?;

println!("{}", account.account_id);
println!("{}", account.legend_wallet_address);

The response includes two addresses:

signer_address — Your signing key’s address (what you generated in step 2)
legend_wallet_address — The on-chain smart wallet Legend created for this account

These are different. The wallet address is where funds live.

Fund the wallet, not the signer. To use this account, send assets to the legend_wallet_address on a supported network (Base, Ethereum Mainnet, Arbitrum, or Optimism). This is mainnet — start with a small amount (e.g., 1 USDC) to test your integration.

5. Create an earn plan

Once the wallet is funded, create a plan. Legend generates the on-chain transaction details and returns an EIP-712 digest for signing.

curl -X POST https://prime-api.legend.xyz/accounts/$ACCOUNT_ID/plan/earn \
  -H "Authorization: Bearer $LEGEND_QUERY_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "1000000",
    "asset": "USDC",
    "network": "base",
    "protocol": "compound"
  }'

const plan = await client.plan.earn(account.account_id, {
  amount: "1000000",   // 1 USDC (6 decimals)
  asset: "USDC",
  network: "base",
  protocol: "compound",
});

plan = await client.plan.earn(
    account["account_id"],
    amount="1000000",   # 1 USDC (6 decimals)
    asset="USDC",
    network="base",
    protocol="compound",
)

use legend_client::EarnParams;

let plan = client.plan.earn(&account.account_id, &EarnParams {
    amount: "1000000".into(),   // 1 USDC (6 decimals)
    asset: "USDC".into(),
    network: "base".into(),
    protocol: "compound".into(),
    market: None,
}).await?;

Plans expire after 2 minutes. Sign and execute before expires_at or create a new plan.

6. Sign the plan

The signer approves the plan by signing the EIP-712 digest. This happens locally — the private key never leaves your infrastructure.

const digest = plan.details.eip712_data.digest;
const signature = await signer.sign({ hash: digest });

digest = plan["details"]["eip712_data"]["digest"]
sig = signer.unsafe_sign_hash(bytes.fromhex(digest[2:]))
signature = "0x" + sig.signature.hex()

let digest = plan.digest().expect("Plan missing digest");
// Sign with legend-signer or your own EIP-712 signer

7. Execute the plan

Send the signature back to Legend. This triggers the on-chain transaction.

curl -X POST https://prime-api.legend.xyz/accounts/$ACCOUNT_ID/plan/execute \
  -H "Authorization: Bearer $LEGEND_QUERY_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "plan_id": "'"$PLAN_ID"'",
    "signature": "'"$SIGNATURE"'"
  }'

const result = await client.plan.execute(account.account_id, {
  planId: plan.plan_id,
  signature,
});

console.log(result.status); // "executing"

result = await client.plan.execute(
    account["account_id"],
    plan_id=plan["plan_id"],
    signature=signature,
)

print(result["status"])  # "executing"

use legend_client::ExecuteParams;

let result = client.plan.execute(&account.account_id, &ExecuteParams {
    plan_id: plan.plan_id.clone(),
    signature: signature.into(),
}).await?;

8. Verify the result

Poll the activities endpoint to confirm the transaction landed.

curl https://prime-api.legend.xyz/accounts/$ACCOUNT_ID/activities \
  -H "Authorization: Bearer $LEGEND_QUERY_KEY"

const { activities } = await client.accounts.activities(account.account_id);

console.log(activities[0].activity_status); // "pending" → "confirmed"

res = await client.accounts.activities(account["account_id"])

print(res["activities"][0]["activity_status"])  # "pending" → "confirmed"

let activities = client.accounts.activities(&account.account_id).await?;

For real-time updates instead of polling, use the events endpoint with poll=true for long-polling.

Full example

Here’s the complete flow in one script:

import { LegendPrime } from "legend-prime";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";

const client = new LegendPrime({
  queryKey: process.env.LEGEND_QUERY_KEY,
});

// 1. Generate a signer
const privateKey = process.env.SIGNER_PRIVATE_KEY as `0x${string}` ?? generatePrivateKey();
const signer = privateKeyToAccount(privateKey);

// 2. Create account
const account = await client.accounts.create({
  signerType: "eoa",
  signerAddress: signer.address,
});

// 3. Fund account.legend_wallet_address with USDC on Base, then...

// 4. Create earn plan
const plan = await client.plan.earn(account.account_id, {
  amount: "1000000",
  asset: "USDC",
  network: "base",
  protocol: "compound",
});

// 5. Sign
const signature = await signer.sign({
  hash: plan.details.eip712_data.digest,
});

// 6. Execute
await client.plan.execute(account.account_id, {
  planId: plan.plan_id,
  signature,
});

// 7. Poll for confirmation
for (let i = 0; i < 30; i++) {
  const { activities } = await client.accounts.activities(account.account_id);
  if (activities.length > 0 && activities[0].activity_status === "confirmed") {
    console.log("Transaction confirmed!");
    break;
  }
  await new Promise((r) => setTimeout(r, 2000));
}

import asyncio
import os
from eth_account import Account
from legend_prime import LegendPrime

async def main():
    async with LegendPrime(
        query_key=os.environ["LEGEND_QUERY_KEY"],
    ) as client:
        # 1. Generate a signer
        signer = Account.from_key(os.environ.get("SIGNER_PRIVATE_KEY") or Account.create().key)

        # 2. Create account
        account = await client.accounts.create(
            signer_type="eoa",
            signer_address=signer.address,
        )

        # 3. Fund account["legend_wallet_address"] with USDC on Base, then...

        # 4. Create earn plan
        plan = await client.plan.earn(
            account["account_id"],
            amount="1000000",
            asset="USDC",
            network="base",
            protocol="compound",
        )

        # 5. Sign
        digest = plan["details"]["eip712_data"]["digest"]
        sig = signer.unsafe_sign_hash(bytes.fromhex(digest[2:]))
        signature = "0x" + sig.signature.hex()

        # 6. Execute
        await client.plan.execute(
            account["account_id"],
            plan_id=plan["plan_id"],
            signature=signature,
        )

        # 7. Poll for confirmation
        for _ in range(30):
            res = await client.accounts.activities(account["account_id"])
            if res["activities"] and res["activities"][0]["activity_status"] == "confirmed":
                print("Transaction confirmed!")
                break
            await asyncio.sleep(2)

asyncio.run(main())

use legend_client::{LegendPrime, Config, CreateAccountParams, EarnParams, ExecuteParams};
use legend_signer::{FileSigner, Signer};
use std::path::Path;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = LegendPrime::new(Config {
        query_key: std::env::var("LEGEND_QUERY_KEY").unwrap(),
        base_url: None,
    });

    // 1. Generate a signer (or load existing)
    let signer = FileSigner::generate(Path::new("key.pem"))?;

    // 2. Create account
    let account = client.accounts.create(&CreateAccountParams {
        signer_type: "eoa".into(),
        ethereum_signer_address: Some(signer.public_key_hex()),
        ..Default::default()
    }).await?;

    // 3. Fund account.legend_wallet_address with USDC on Base, then...

    // 4. Create earn plan
    let plan = client.plan.earn(&account.account_id, &EarnParams {
        amount: "1000000".into(),
        asset: "USDC".into(),
        network: "base".into(),
        protocol: "compound".into(),
        market: None,
    }).await?;

    // 5. Sign
    let digest = plan.digest().expect("Plan missing digest");
    // Sign with legend-signer or your own EIP-712 signer
    let signature = "0x..."; // your signature here

    // 6. Execute
    client.plan.execute(&account.account_id, &ExecuteParams {
        plan_id: plan.plan_id.clone(),
        signature: signature.into(),
    }).await?;

    // 7. Poll for confirmation
    for _ in 0..30 {
        let activities = client.accounts.activities(&account.account_id).await?;
        if !activities.is_empty() {
            println!("Transaction confirmed!");
            break;
        }
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    }

    Ok(())
}

Next steps

Withdraw funds from a DeFi position
Transfer assets to another wallet
Monitor activities with events and long-polling
API Reference for all available endpoints

Getting Started

Guides

Concepts

Accounts

Portfolio

Plans

Activities & Events

Reference Data

SDKs

Agent Integration

MCP Server

Agent Guides

Quickstart

Quickstart

Prerequisites

1. Install the SDK

2. Generate a signer key

3. Initialize the client

4. Create a sub-account

5. Create an earn plan

6. Sign the plan

7. Execute the plan

8. Verify the result

Full example

Next steps

​Quickstart

​Prerequisites

​1. Install the SDK

​2. Generate a signer key

​3. Initialize the client

​4. Create a sub-account

​5. Create an earn plan

​6. Sign the plan

​7. Execute the plan

​8. Verify the result

​Full example

​Next steps

Quickstart

Prerequisites

1. Install the SDK

2. Generate a signer key

3. Initialize the client

4. Create a sub-account

5. Create an earn plan

6. Sign the plan

7. Execute the plan

8. Verify the result

Full example

Next steps