How It Works#

The API gateway is a stateless proxy — it authenticates the API key and forwards requests to the TEE. Everything security-critical (keys, signing, policy checks) happens exclusively inside the Trusted Execution Environment.

1. Register — one API call creates a wallet and returns an API key. The TEE derives the private key from the MPC master secret and returns the public key. No blockchain transaction needed.
2. Operate — the agent uses the API key to transfer NEAR, swap tokens, call smart contracts, or withdraw cross-chain. The TEE checks the policy, signs the transaction, and broadcasts it to the NEAR network.
3. Control — the wallet owner configures policies for the agent via the dashboard: spending limits, address whitelists, transaction confirmations, multisig, or instant freeze.

Agent ID#

Every wallet is identified by its Agent ID — a public key derived deterministically inside the TEE from the MPC master secret. The agent receives an API key for authentication, while the Agent ID serves as the on-chain identity.

The agent uses the API Key to authenticate all requests. The private key behind the Agent ID never leaves the TEE — transactions are signed inside the secure enclave and the agent never has access to it.

Multi-Chain Support#

The wallet is NEAR-native: its identity and signing key live on NEAR, and its cross-chain value is custodied on intents.near. You move value across chains the way you would with a centralized exchange — deposit in, operate, withdraw out to an external address — all via the NEAR Intents protocol and the 1Click solver network. No bridges, and no gas tokens needed on the destination chain.

The wallet signs EVM payloads directly. GET /wallet/v1/address returns the NEAR address and a single shared secp256k1 0x address (the same across all EVM chains), and the wallet signs EIP-712 typed data, EIP-191 messages, and raw EVM transactions via /wallet/v1/evm/* — you build and broadcast the transaction; the TEE only keccak-hashes and signs. Solana works the same way via /wallet/v1/solana/*: the wallet has its own base58 ed25519 address and signs off-chain messages and serialized transaction messages (base58 signature); you assemble and broadcast. Cross-chain deposits and withdrawals via NEAR Intents do not need any of this.

Policy Engine#

The wallet owner controls the agent's permissions through a policy — a set of rules that are encrypted and stored on-chain. The policy is decrypted and evaluated inside the TEE on every transaction. The agent cannot bypass or modify it.

Policies are stored encrypted on-chain (on the NEAR blockchain). Only the TEE can decrypt and evaluate them. This means neither the API gateway operator nor the agent can see or tamper with the raw policy rules.

Example Policy

{
  "rules": {
    "transaction_types": ["transfer", "call", "withdraw", "swap", "delete"],
    "allowed_tokens": ["*"],
    "addresses": {
      "mode": "whitelist",
      "list": ["bob.near", "dex.near"]
    },
    "limits": {
      "per_transaction": { "native": "10000000000000000000000000" },
      "daily": { "*": "100000000000000000000000000" },
      "hourly": { "*": "50000000000000000000000000" }
    },
    "rate_limit": { "max_per_hour": 60 },
    "time_restrictions": {
      "timezone": "UTC",
      "allowed_hours": [9, 17],
      "allowed_days": [1, 2, 3, 4, 5]
    }
  },
  "approval": {
    "threshold": { "required": 2 },
    "approvers": [
      { "id": "alice.near", "role": "admin",  "pubkey": "ed25519:<base58>" },
      { "id": "bob.near",   "role": "signer", "pubkey": "ed25519:<base58>" },
      { "id": "carol.near", "role": "signer", "pubkey": "ed25519:<base58>" }
    ]
  },
  "capabilities": {
    "raw_sign":     { "allowed": false, "chains": ["ethereum", "solana"], "requires_approval": true },
    "confidential": { "allowed": false },
    "sign_message": { "allowed": true,  "allowed_recipients": [] },
    "swap":         { "allowed": false },
    "cross_chain_withdraw": { "allowed": false },
    "payment_check": { "allowed": false },
    "evm_sign":     { "allowed": true,  "raw_tx": false },
    "solana_sign":  { "allowed": false, "raw_tx": false }
  }
}

Multisig Approval#

On a wallet with an approval threshold, fund-moving operations go into a pending state. Designated approvers sign the request using their NEAR wallet (NEP-413 signature). Once the required number of signatures is collected, the transaction executes automatically.

Agent: POST /wallet/v1/intents/withdraw { amount: "$5,000" }
  -> Response: { status: "pending_approval", required: 2, approved: 0 }

Approver 1: Signs approval via NEAR wallet (dashboard)
  -> { approved: 1, required: 2 }

Approver 2: Signs approval via NEAR wallet (dashboard)
  -> Threshold met -> auto-execute -> { status: "success", tx_hash: "..." }

Quick Start#

1. Register a wallet

curl -s -X POST https://api.outlayer.fastnear.com/register

# Response:
# {
#   "api_key": "wk_15807dbda492...",
#   "near_account_id": "36842e2f73d0...",
#   "handoff_url": "https://outlayer.fastnear.com/wallet?key=wk_..."
# }

The api_key is shown only once. Store it securely.

2. Get address

# NEAR address (wallet identity; chain=near only — native ETH/SOL
# addresses are not issued, see Multi-Chain Support above)
curl -s -H "Authorization: Bearer $API_KEY" \
  "https://api.outlayer.fastnear.com/wallet/v1/address?chain=near"

# To fund from another chain, request a cross-chain deposit address
# (via 1Click / NEAR Intents). Pass a defuse `source_asset` from
# GET /wallet/v1/tokens — the source chain is derived from its prefix
# (e.g. `eth-…` → Ethereum).
# ⚠️ Only send the exact whitelisted token on the exact chain below —
#    any other asset sent to this address is lost permanently.
# (Legacy alias /wallet/v1/deposit-intent still works.)
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"source_asset":"nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near","amount":"10000000"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/deposit/cross-chain"

# Returned `deposit_address` format depends on the source chain:
# NEAR — 64-char hex implicit account; EVM — 0x + 40 hex;
# Solana — base58; Bitcoin — bc1…/1…/3….
# For NEAR-source funds prefer POST /wallet/v1/intents/deposit
# (one direct ft_transfer_call, ~3s, no solver hop).

3. Check balance

# Native NEAR balance
curl -s -H "Authorization: Bearer $API_KEY" \
  "https://api.outlayer.fastnear.com/wallet/v1/balance?chain=near"

# FT token balance (e.g. USDT)
curl -s -H "Authorization: Bearer $API_KEY" \
  "https://api.outlayer.fastnear.com/wallet/v1/balance?chain=near&token=usdt.tether-token.near"

4. Transfer NEAR

curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"bob.near","amount":"1000000000000000000000000"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/transfer"

5. Swap tokens

# Swap wNEAR -> USDT (handles deposit, storage, and settlement automatically)
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"token_in":"nep141:wrap.near","token_out":"nep141:usdt.tether-token.near","amount_in":"1000000000000000000000000"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/swap"

6. Call a NEAR contract

curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"receiver_id":"wrap.near","method_name":"near_deposit","args":{},"deposit":"10000000000000000000000"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/call"

If the transaction is broadcast but its execution reverts on-chain (contract panic, out of gas), the response is HTTP 422 witherror: onchain_tx_failed, the decoded execution error, and the real tx_hash — the transaction is on chain, so do not retry it. Same contract on/transfer,/delete,/storage-deposit and/intents/deposit. For operations that go through multisig approval, execution happens in the background after the threshold is met — a revert there surfaces asstatus: "failed" viaGET /wallet/v1/requests/{id} and therequest_completed webhook, not as a synchronous 422.

7. Withdraw (gasless cross-chain via Intents)

# Tokens must be in Intents balance first (use /intents/deposit or /swap).
# Only whitelisted Intents assets can be withdrawn (see GET /wallet/v1/tokens).

# Withdraw NATIVE NEAR (default for chain=near): intents.near unwraps your wNEAR
# and sends native NEAR. Gasless, and the recipient needs NO wrap.near storage.
# amount is in yoctoNEAR (24 decimals) — 1 NEAR = 1000000000000000000000000.
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"receiver.near","amount":"1000000000000000000000000","token":"near","chain":"near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/withdraw"

# Withdraw wNEAR (NEP-141) instead — explicit opt-in; recipient must be
# storage-registered on wrap.near (POST /wallet/v1/storage-deposit):
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"receiver.near","amount":"1000000000000000000000000","token":"nep141:wrap.near","chain":"near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/withdraw"

# Withdraw USDT (NEP-141) to a NEAR account (recipient must have usdt storage):
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"receiver.near","amount":"1000000","token":"usdt.tether-token.near","chain":"near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/withdraw"

# Withdraw cross-chain to an external address (1Click bridges + delivers native):
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"0xRecipient...","amount":"1000000","token":"usdt.tether-token.near","chain":"ethereum"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/withdraw"

Cross-chain withdrawals: prefer "async": true. The 1Click bridge can take longer than the synchronous response window, so add "async": true to the body. The call then returns immediately with status: "processing" and a poll_url; poll GET /wallet/v1/requests/{request_id} until terminal. Same-chain NEAR settles in seconds, so async is optional there.

8. Transfer inside Intents (to another account)

Move a token from your Intents balance to another account's Intents balance, gasless, staying inside intents.near — the recipient is credited there, nothing lands on the public chain. This is not a withdrawal: use it when the recipient also holds an Intents balance (e.g. another OutLayer custody wallet); use /intents/withdraw to deliver to a plain on-chain account instead. NEAR-only (no chain field); token is required (to send NEAR, transfer nep141:wrap.near). The recipient need not exist on-chain.

# Transfer 1 USDT to another account's Intents balance (gasless, stays inside Intents):
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"to":"partner.near","amount":"1000000","token":"nep141:usdt.tether-token.near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/intents/transfer"

9. Delete wallet (irreversible)

Delete the on-chain account, send all NEAR to a beneficiary, and revoke all API keys:

curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"beneficiary":"receiver.near","chain":"near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/delete"

10. Configure policy (optional)

Share the handoff URL with the wallet owner so they can set spending limits, whitelists, and multisig rules from the dashboard:

https://outlayer.fastnear.com/wallet?key=wk_...

API Reference#

All endpoints except /register require the Authorization: Bearer <api_key> header.

Base URL: https://api.outlayer.fastnear.com (mainnet) · https://testnet-api.outlayer.fastnear.com (testnet)

Confidential Intents#

Move balances between your public intents shard, a confidential shielded-pool shard, and external chains — same TEE-mediated signing, a different shard. The /wallet/v1/confidential/* routes mirror /wallet/v1/intents/*. Like all Intents flows they are mainnet-only — they return HTTP 503 on testnet (no testnet solvers) or wherever the deployment has not enabled confidential intents. The confidential shard is the intents.far contract on a private NEAR shard with no public RPC: balances are real on-chain state there, just not publicly readable. Full integration guide: CONFIDENTIAL_INTENTS.md.

• POST /confidential/shield — SHIELD: public intents → confidential (legacy alias /confidential/deposit, still works)
• POST /confidential/unshield — confidential → public intents
• POST /confidential/withdraw — confidential → external chain (or chain="near" for native NEAR delivery via native_withdraw)
• POST /confidential/transfer — private confidential → confidential transfer
• POST /confidential/swap (+ /swap/quote, /withdraw/dry-run) — on a multisig wallet, like a public swap, approval controls whether it runs (the TEE does not itself re-check the swap's token/amount against the artifact — that relies on gateway trust)
• POST /confidential/deposit/cross-chain — cross-chain deposit (via 1Click / NEAR Intents; legacy alias /confidential/deposit-intent, still works)
• GET /confidential/balance — read confidential balances

Action routes are asynchronous — they return request_id with status pending_deposit; poll GET /wallet/v1/requests/{id} until terminal.

# SHIELD 0.01 wNEAR into the confidential shard
# (legacy alias /wallet/v1/confidential/deposit still works)
curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"token":"nep141:wrap.near","amount":"10000000000000000000000"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/confidential/shield"

# Read confidential balances
curl -s -H "Authorization: Bearer $API_KEY" \
  "https://api.outlayer.fastnear.com/wallet/v1/confidential/balance"

Delete Wallet#

Permanently delete the wallet's on-chain NEAR account using the native DeleteAccount action. All remaining native NEAR balance is automatically sent to the beneficiary. All API keys are revoked.

Before deleting

1. Transfer all FT tokens via POST /wallet/v1/call with ft_transfer
2. Withdraw Intents balances via POST /wallet/v1/intents/withdraw
3. Move any other on-chain assets to another account

Request

curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"beneficiary":"receiver.near","chain":"near"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/delete"

Response

{
  "request_id": "uuid",
  "status": "success",
  "tx_hash": "...",
  "beneficiary": "receiver.near"
}

After deletion, the on-chain account no longer exists and all API keys are revoked. Subsequent API requests will return invalid_api_key.

Sign Message (NEP-413)#

Sign an arbitrary message using the wallet's NEAR private key following the NEP-413 standard. Use this to authenticate your agent to external services that verify NEAR signatures — no on-chain transaction needed.

Request

curl -s -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"message":"Login to example.com","recipient":"example.com"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/sign-message"

Response

{
  "account_id": "aabbccdd11223344...",
  "public_key": "ed25519:...",
  "signature": "ed25519:...",
  "nonce": "base64-encoded-32-bytes"
}

Parameters

Deterministic Wallets#

For servers, bots, and agents with a NEAR account: create wallets that require zero per-user key storage. The wallet ID is derived from (account_id, seed, vault_or_none) — same inputs always produce the same wallet, and different vault scopes legitimately mint independent sub-wallets under the same seed. Auth uses NEAR ed25519 signatures on every request instead of stored API keys. Seed format: [a-zA-Z0-9._-], 1-256 chars.

Two auth methods

Signature format

All signatures are raw ed25519 — sign the message string bytes directly with your NEAR key, then base58-encode the 64-byte result. This is NOT NEP-413 (the /sign-message endpoint returns NEP-413 signatures, which are a different format and won't work here).

Register a deterministic wallet

# Sign "register:<seed>:<timestamp>" with your NEAR ed25519 key (raw, not NEP-413)
curl -s -X POST -H "Content-Type: application/json" \
  -d '{
    "account_id": "my-bot.near",
    "seed": "user-42",
    "pubkey": "ed25519:<base58_pubkey>",
    "message": "register:user-42:1712000000",
    "signature": "<base58_signature>"
  }' \
  "https://api.outlayer.fastnear.com/register"

# Timestamp window: ±5 minutes for registration
# Response: { "wallet_id": "...", "near_account_id": "..." }
# No api_key — use Bearer near:... for all requests

Bearer near: token format

Base64url-encode a JSON object. The signed message format depends on whether you include a vault scope (±30s window):

• No vault: auth:<seed>:<timestamp>
• With vault: auth:<seed>:<timestamp>:<vault_id> — vault_id MUST be inside the signed message (not only in JSON), otherwise verify fails with 401.

{
  "account_id": "my-bot.near",
  "seed": "user-42",
  "pubkey": "ed25519:<base58>",
  "timestamp": 1712000000,
  "signature": "<base58>",
  "vault_id": "vault.my-bot.near"   // optional; include in signed message too
}

Delegate keys for sub-agents

Register a wk_ key hash so a sub-agent can use simple Bearer auth. Works from both custody wallets (Bearer wk_...) and external NEAR accounts (signature in body).

# From a custody wallet — just pass your Bearer token, no NEAR signatures needed
# key_hash = SHA256("wk_" + derived_key_hex)
curl -s -X PUT -H "Authorization: Bearer $API_KEY" -H "Content-Type: application/json" \
  -d '{"seed": "sub-task", "key_hash": "<sha256_hex_of_wk_key>"}' \
  "https://api.outlayer.fastnear.com/wallet/v1/api-key"
# Response: { "wallet_id": "...", "near_account_id": "..." }

# Sub-agent: simple Bearer token, no crypto
curl -H "Authorization: Bearer wk_derived_key_here" \
  "https://api.outlayer.fastnear.com/wallet/v1/balance?chain=near"

# Revoke: DELETE /wallet/v1/api-key/{key_hash}
# Returns 409 if last active key for the wallet

Key rotation

No endpoint needed. Add a new key to your NEAR account, start signing with it, remove the old key. Old key access is revoked within 60 seconds (cache TTL). Wallet identity is tied to (account_id, seed, vault_or_none), not to which key signs.

Security Model#

AI Agent Skill File#

For AI agents that support skill files (Claude MCP, OpenAI functions, etc.), OutLayer provides a ready-to-use skill definition that teaches the agent how to register, fund, and operate the wallet.

# Fetch the skill file
curl -s https://skills.outlayer.ai/agent-custody/SKILL.md

The skill file contains step-by-step instructions, API reference, error handling, and guidelines for the AI agent. Point your agent framework to this URL and the agent will know how to set up and use its wallet automatically.

OutLayer CLI Integration#

Agents with custody wallets can use the OutLayer CLI directly — no NEAR private key needed. Login with the wallet API key and all commands route signing through the coordinator's wallet API transparently.

# Login with wallet key (instead of NEAR private key)
outlayer login --wallet-key wk_15807dbda492636df5280629d7617c3ea80f915ba960389b621e420ca275e545

# All commands work transparently
outlayer deploy my-agent
outlayer keys create
outlayer run alice.near/my-agent '{"test": true}'
outlayer secrets set '{"API_KEY":"sk-..."}' --project alice.near/my-agent
outlayer earnings

Supported commands

Comparison with Traditional Custody#

Dashboard#

The wallet owner manages everything through the OutLayer dashboard. The agent only sees the API.