<!--
Sitemap:
- [Stridge — The infrastructure bridging crypto payments](/index): Crypto payment infrastructure for modern fintechs. Accept on any chain, settle through the cheapest route, and pay out in any asset — all from a single SDK.
- [API Reference](/api-reference/): Stridge REST API reference — complete endpoint documentation for deposits, payouts, Universal Deposit Addresses, settlements, and supported networks.
- [Changelog](/changelog): Release notes for Stridge SDKs and developer tools.
- [Stridge Gateway Kit](/gateway/): Drop-in deposit and withdraw flows for crypto apps. Mount a single React provider, render a dialog, and ship any-to-any payments in minutes.
- [Getting Started](/getting-started): Get started with Stridge — pick your integration shape, generate keys, and make your first call from the React Kit, the TypeScript SDK, or the REST API.
- [Supported Networks](/networks): Blockchain networks and tokens supported by the Stridge payment infrastructure — network_id (SLIP-44), EIP-155 chain IDs, and the available native and stablecoin assets per chain.
- [TypeScript SDK](/sdk/): TypeScript client for the Stridge Gateway API. Used internally by @stridge/kit and exposed for backend and server integrations that need direct API access.
- [Security](/security/): Stridge Security — how the Stridge KMS protects wallet keys and signs transactions without ever exposing private keys.
- [Universal Deposit Addresses](/uda/): Universal Deposit Addresses (UDA) — one multi-chain deposit address per user, with automatic cross-chain settlement to a fixed destination.
- [Webhooks](/webhooks/): Stridge webhooks — signed HTTP POSTs for deposits, UDA settlements, wallets, and balances. Verify HMAC, handle retries, and use the Dashboard to inspect event payloads.
- [Gateway HTTP API](/gateway/http): Raw HTTP contract for the Stridge Gateway — supported-assets catalogue, gateway/start provisioning, and per-owner status polling.
- [UDA Quickstart](/uda/quickstart): Create your first Universal Deposit Address and trace a deposit end-to-end — from the POST call, through webhooks, to a settled transaction on the destination chain.
- [Settlements](/uda/settlements): UDA settlements — lifecycle, routing scenarios, fees, and the settlement record API. Reconcile deposits with webhooks; the Dashboard shows each settlement end-to-end.
- [UDA Webhook Events](/uda/webhooks): Reference for the three webhook events UDA deposits emit — deposit.confirmed, uda.settlement.created, and uda.settlement.completed — with payloads and lifecycle guidance.
- [Get a single deposit transaction by ID](/api-reference/deposits/get-a-single-deposit-transaction-by-id): Get details of a specific deposit transaction by its unique ID
- [Get a single deposit transaction by transaction id](/api-reference/deposits/get-a-single-deposit-transaction-by-transaction-id): One row per matching tx_id; multiple same-tx transfers are separate rows. Returns the latest by on-chain time (then id). Use GET /v1/deposits with tx_id filter
- [List deposit transactions](/api-reference/deposits/list-deposit-transactions): Get a paginated list of deposit transactions for the authenticated tenant with filtering support
- [Get blockchain assets](/api-reference/networks/get-blockchain-assets): Get a list of all supported blockchain assets (tokens and native assets).
- [Get blockchain networks](/api-reference/networks/get-blockchain-networks): Get a list of all supported blockchain networks.
- [Get network list](/api-reference/networks/get-network-list): Get a public list of all networks with category grouping.
- [Get tenant network](/api-reference/networks/get-tenant-network): Get a specific network for the authenticated tenant by network ID and contract address
- [Get tenant networks](/api-reference/networks/get-tenant-networks): Get a list of networks available to the authenticated tenant with their enabled status
- [Update tenant network status](/api-reference/networks/update-tenant-network-status): Update the enabled status of a network for the authenticated tenant
- [Create payout](/api-reference/payouts/create-payout): Creates a new payout from the tenant's vault wallet to an external address
- [Create payout with USD amount](/api-reference/payouts/create-payout-with-usd-amount): Creates a new payout converting a USD amount to crypto at current rate
- [Get payout by ID](/api-reference/payouts/get-payout-by-id): Retrieves a payout by its ID
- [Get vault address by network](/api-reference/payouts/get-vault-address-by-network): Get the vault address for a specific network
- [Get vault balances](/api-reference/payouts/get-vault-balances): Get balances for all vault addresses with optional filtering
- [Get vault total value](/api-reference/payouts/get-vault-total-value): Get the total USD value across all vault assets
- [List payouts](/api-reference/payouts/list-payouts): Lists payouts for a vault with filtering and pagination
- [List vault addresses](/api-reference/payouts/list-vault-addresses): Get all vault addresses for the authenticated tenant
- [List vaults](/api-reference/payouts/list-vaults): List all vault accounts for the authenticated tenant
- [Transfer from vault to external address](/api-reference/payouts/transfer-from-vault-to-external-address): Transfer assets from the tenant's vault wallet to an external address.
- [Get a settlement](/api-reference/settlements/get-a-settlement): Fetch a single settlement by ID. A settlement is created per confirmed deposit on a UDA address and carries the lifecycle state, scenario, and routing tx ids.
- [Create a UDA address](/api-reference/uda/create-a-uda-address): Allocate a new Universal Deposit Address for the tenant. If a UDA for the (tenant, owner) pair already exists, the existing record is returned with 200 instead
- [Get a cross-chain / cross-token quote](/api-reference/uda/get-a-cross-chain-cross-token-quote): Returns an indicative quote for routing from/to given (chain, token) pair. USD fields are omitted until a price feed is wired in.
- [Get a UDA address](/api-reference/uda/get-a-uda-address): Fetch a single UDA address by ID, including its delegation status.
- [List settlements for a UDA address](/api-reference/uda/list-settlements-for-a-uda-address): List all settlements that have been created for a given UDA address, optionally paginated.
- [List UDA addresses](/api-reference/uda/list-uda-addresses): List UDA addresses belonging to the authenticated tenant. Supports filtering by owner and status and pagination via limit/offset.
- [List UDA-supported chains](/api-reference/uda/list-uda-supported-chains): Returns every chain with `uda_support=true` along with its native currency and configured token contracts. Rows are grouped by network.
- [Retire a UDA address](/api-reference/uda/retire-a-uda-address): Mark a UDA address as retired. Future deposits will no longer trigger settlements; any already-confirmed settlements continue to run to completion.
- [Update a UDA address](/api-reference/uda/update-a-uda-address): Update the destination, accepted tokens, or status of an existing UDA. Owner is immutable.
-->

# Universal Deposit Addresses \[One address, every supported chain, automatic settlement]

**Universal Deposit Addresses (UDA)** turn a single API call into a
deposit address that works across every supported EVM chain and every
supported token. Any incoming deposit is detected, routed, swapped or
bridged as needed, and settled to a fixed destination you pick up
front.

In one sentence: **set it up once, deposit forever, from any chain.**

:::info
Phase 1 covers EVM chains — Ethereum, Arbitrum, Base, BNB Smart Chain,
and Polygon. Non-EVM chains (Tron, Solana, Bitcoin) and fiat on-ramps
are on the roadmap.
:::

## Why UDA

Cross-chain deposits are painful for end users and expensive for
integrators:

* Users have to pick the right network, bridge, and swap before they
  can deposit.
* Integrators build per-chain deposit logic, wallet provisioning, and
  settlement themselves.
* Ephemeral per-checkout addresses can't be reused, can't be shown in
  a user profile, and force reconfiguration on every flow.

UDA replaces all of that with a single persistent address per user
(or account, or email). Every deposit — on any chain, in any accepted
token — lands in the destination you configured.

## How a UDA works

:::::steps

### Create a UDA

Call [`POST /v1/uda`](/api-reference/uda/create-a-uda-address) once
per `owner`. Stridge provisions deposit addresses on every supported
EVM chain and returns them as a single UDA record.

### User deposits from any chain

The user sends any accepted token on any supported chain to the
address. They don't have to pick a network in your UI — every chain
is already wired up and listening.

### Stridge detects the deposit

The Observer service emits a `deposit.confirmed` webhook as soon as
the transaction is confirmed. The payload marks
`to_wallet_category: "uda"` so you can distinguish UDA deposits from
regular wallet deposits.

### UDA opens a settlement

The UDA service opens a settlement and fires
`uda.settlement.created`. The Routing Engine quotes across providers
(LI.FI, Relay), picks the best route, and executes — swap, bridge, or
both.

### Settlement webhook fires

You receive `uda.settlement.completed` the moment funds land in the
destination token on the destination chain. The same UDA keeps
working forever — no re-creation required.

:::::

```text
Integrator ── POST /v1/uda ──▶ UDA Service ──▶ returns multi-chain addresses
                                     │
User deposits on any chain ──▶ Observer ──▶ deposit.confirmed
                                     │
                                     ▼
                             UDA opens a settlement ──▶ uda.settlement.created
                                     │
                                     ▼
                             Routing Engine quotes & executes
                                     │
                                     ▼
                             uda.settlement.completed
```

## Creating a UDA

The minimum request is an `owner` and a `destination`. `owner` is a
stable identifier for your user — a wallet address, user id, or email
all work. `destination` is the address and token where every deposit
will ultimately land.

```json [POST /v1/uda]
{
  "accepted_tokens": ["USDC", "USDT", "ETH"],
  "destination": {
    "address": "0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e",
    "asset_symbol": "USDC",
    "network_id": "9001"
  },
  "owner": "user_8a7f3c"
}
```

| Field                     | Required | Notes                                                                                     |
| ------------------------- | -------- | ----------------------------------------------------------------------------------------- |
| `owner`                   | yes      | Any stable identifier — wallet address, internal user id, or email                        |
| `destination.address`     | yes      | Where settled funds land                                                                  |
| `destination.network_id`  | yes      | Stridge `network_id` of the destination chain                                             |
| `destination.asset_symbol`| no       | Settlement asset — defaults to the destination chain's native token if omitted            |
| `accepted_tokens`         | no       | Token-symbol whitelist for all deposit chains. Omit to accept every configured token      |

:::tip
`accepted_tokens` filters which tokens Stridge will route on the
**source** side. It does not change which network a user can deposit
on — every supported chain is always active.
:::

Calls are idempotent by `(tenant, owner)`: posting the same `owner`
twice returns the existing UDA with `200 OK` instead of creating a
duplicate.

### Response

```json
{
  "id": "31d32b68-e455-42b7-9d39-d2904adbe1b8",
  "status": "active",
  "owner": "user_8a7f3c",
  "destination": {
    "address": "0x8f4a2c9e1b3d7f5a6c8e0d9b2a4c6e8f0a2c4d6e",
    "eip155_id": "42161",
    "network_id": "9001",
    "network_name": "arbitrum",
    "token_address": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
    "token_symbol": "USDC",
    "token_decimals": 6
  },
  "deposit_addresses": [
    {
      "eip155_id": "1",
      "network_name": "ethereum",
      "address": "0x3b7e9d1a5c2f4b8e6d0c9f3a2b1e4d5c7a9b8e0f",
      "accepted_tokens": [
        { "symbol": "USDC", "address": "0xa0b8…eb48", "decimals": 6 },
        { "symbol": "USDT", "address": "0xdac1…1ec7", "decimals": 6 }
      ]
    },
    {
      "eip155_id": "8453",
      "network_name": "base",
      "address": "0x3b7e9d1a5c2f4b8e6d0c9f3a2b1e4d5c7a9b8e0f",
      "accepted_tokens": [
        { "symbol": "USDC", "address": "0x8335…2913", "decimals": 6 }
      ]
    }
  ]
}
```

Full schema and error codes in the API reference:
[`Create a UDA address`](/api-reference/uda/create-a-uda-address).

## Supported chains & tokens

UDA accepts deposits on every chain returned by
[`GET /v1/uda/supported-chains`](/api-reference/uda/list-uda-supported-chains).
The list is refreshed whenever a new network is onboarded and is safe
to cache per-request.

| Network         | `eip155_id` | `network_id` |
| --------------- | ----------- | ------------ |
| Ethereum        | `1`         | `60`         |
| BNB Smart Chain | `56`        | `9006`       |
| Base            | `8453`      | `8453`       |
| Arbitrum One    | `42161`     | `9001`       |
| Polygon PoS     | `137`       | `9002`       |

See [Supported Networks](/networks) for the full matrix (identifiers,
native assets, scanners).

Phase 1 tokens include native coins (ETH, BNB, POL) and the main
stablecoins (USDC, USDT) on every chain above. Query
`supported-chains` at runtime to get the authoritative list for your
tenant.

## Routing scenarios

Every combination of source and destination is handled automatically
in Phase 1:

| Scenario                     | Example                              | Route              |
| ---------------------------- | ------------------------------------ | ------------------ |
| Same chain, same token       | USDC on Arbitrum → USDC on Arbitrum  | Direct transfer    |
| Same chain, different token  | USDT on Arbitrum → USDC on Arbitrum  | DEX swap (LI.FI)   |
| Cross chain, same token      | USDC on Base → USDC on Arbitrum      | Bridge (LI.FI/Relay) |
| Cross chain, different token | BNB on BSC → USDC on Arbitrum        | Swap + bridge      |

The `scenario` field on settlement webhooks and
`GET /v1/settlements/{id}` tells you which path was taken (see
[UDA Webhook events](/uda/webhooks#settlement-events)).

## Webhooks

Three events cover the full lifecycle of a UDA deposit:

| Event                       | Fires when                                                    |
| --------------------------- | ------------------------------------------------------------- |
| `deposit.confirmed`         | On-chain deposit is confirmed at the UDA address              |
| `uda.settlement.created`    | Routing Engine has accepted the deposit and begun execution   |
| `uda.settlement.completed`  | Destination tx has landed; funds are in the destination token |

All UDA webhooks follow the standard
[signed envelope](/webhooks#delivery-format). The full payload
reference lives at [UDA Webhook events](/uda/webhooks).

## API surface

| Endpoint                                                                                            | Purpose                                                |
| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| [`POST /v1/uda`](/api-reference/uda/create-a-uda-address)                                           | Create (or return existing) UDA for an owner           |
| [`GET /v1/uda`](/api-reference/uda/list-uda-addresses)                                              | List UDAs, filter by owner or status                   |
| [`GET /v1/uda/{id}`](/api-reference/uda/get-a-uda-address)                                          | Fetch a UDA with its deposit address set               |
| [`PATCH /v1/uda/{id}`](/api-reference/uda/update-a-uda-address)                                     | Change destination, accepted tokens, or pause/resume   |
| [`DELETE /v1/uda/{id}`](/api-reference/uda/retire-a-uda-address)                                    | Retire a UDA (in-flight settlements still complete)    |
| [`GET /v1/uda/supported-chains`](/api-reference/uda/list-uda-supported-chains)                      | All chains and tokens you can receive on               |
| [`GET /v1/uda/quote`](/api-reference/uda/get-a-cross-chain-cross-token-quote)                       | Indicative fee & time estimate for a given route       |
| [`GET /v1/uda/{id}/settlements`](/api-reference/uda/list-settlements-for-a-uda-address)             | Paginated settlement history for one UDA               |
| [`GET /v1/settlements/{id}`](/api-reference/settlements/get-a-settlement)                           | Single settlement with deposit, route, fees, tx ids    |

## Next

* [UDA Quickstart](/uda/quickstart) — create your first UDA and trace a deposit in under five minutes.
* [UDA Webhook events](/uda/webhooks) — payloads for `deposit.confirmed`, `uda.settlement.created`, `uda.settlement.completed`.
* [Settlements](/uda/settlements) — settlement lifecycle, statuses, and debugging tips.
* [Supported Networks](/networks) — chain identifiers and tokens.