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

# Glossary

> Key terms used across the Etherfuse API and docs.

export const BondMintAccounts = () => {
  const {useState, useEffect} = React;
  const [rows, setRows] = useState(null);
  const [error, setError] = useState(null);
  const EXPLORER = {
    solana: id => 'https://solscan.io/token/' + id,
    stellar: id => 'https://stellar.expert/explorer/public/asset/' + id,
    base: id => 'https://basescan.org/token/' + id,
    polygon: id => 'https://polygonscan.com/token/' + id,
    monad: id => 'https://monadvision.com/token/' + id,
    avalanche: id => 'https://snowtrace.io/token/' + id
  };
  const CHAIN_LABEL = {
    stellar: 'Stellar',
    solana: 'Solana',
    monad: 'Monad',
    base: 'Base',
    polygon: 'Polygon',
    avalanche: 'Avalanche'
  };
  const CHAIN_ORDER = ['stellar', 'solana', 'monad', 'base', 'polygon', 'avalanche'];
  const tokenLogo = s => 'https://stablebonds.s3.us-west-2.amazonaws.com/stablebond/spl-' + String(s).toLowerCase() + '.png';
  const hideOnError = e => {
    e.currentTarget.style.display = 'none';
  };
  useEffect(() => {
    let cancelled = false;
    fetch('https://api.etherfuse.com/lookup/stablebonds').then(r => {
      if (!r.ok) throw new Error('HTTP ' + r.status);
      return r.json();
    }).then(data => {
      if (cancelled) return;
      const bonds = (data.stablebonds || []).filter(b => b.symbol !== 'MEX').sort((a, b) => String(a.symbol).localeCompare(String(b.symbol)));
      setRows(bonds);
    }).catch(e => {
      if (!cancelled) setError(e.message || 'failed to load');
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const border = '1px solid rgba(128,128,128,0.25)';
  const cell = {
    padding: '6px 12px',
    borderBottom: border,
    textAlign: 'left',
    verticalAlign: 'middle'
  };
  const head = {
    ...cell,
    fontWeight: 600
  };
  const mono = {
    fontFamily: 'monospace',
    fontSize: '0.85em',
    wordBreak: 'break-all'
  };
  const inline = {
    display: 'inline-flex',
    alignItems: 'center',
    gap: '6px'
  };
  if (error) return <p>
        Couldn't load the live list. See <code>GET /lookup/stablebonds</code>.
      </p>;
  if (!rows) return <p>Loading live addresses…</p>;
  return <div>
      {rows.map(b => {
    const chains = [...b.blockchains || []].sort((a, z) => CHAIN_ORDER.indexOf(a.blockchain) - CHAIN_ORDER.indexOf(z.blockchain));
    return <div key={b.symbol} style={{
      marginBottom: '1.5rem'
    }}>
            <div style={{
      ...inline,
      marginBottom: '4px'
    }}>
              <img src={tokenLogo(b.symbol)} alt="" width={22} height={22} onError={hideOnError} />
              <strong>{b.symbol}</strong>
              <span style={{
      opacity: 0.6
    }}>· {b.bondCurrency}</span>
            </div>
            <table style={{
      width: '100%',
      borderCollapse: 'collapse',
      fontSize: '0.95em'
    }}>
              <thead>
                <tr>
                  <th style={{
      ...head,
      width: '130px'
    }}>Chain</th>
                  <th style={head}>Address</th>
                </tr>
              </thead>
              <tbody>
                {chains.map(c => {
      const url = EXPLORER[c.blockchain] ? EXPLORER[c.blockchain](c.tokenIdentifier) : null;
      return <tr key={c.blockchain}>
                      <td style={cell}>
                        <span style={inline}>
                          <img src={'/img/chains/' + c.blockchain + '.svg'} alt="" width={16} height={16} onError={hideOnError} />
                          {CHAIN_LABEL[c.blockchain] || c.blockchain}
                        </span>
                      </td>
                      <td style={{
        ...cell,
        ...mono
      }}>
                        {url ? <a href={url} target="_blank" rel="noreferrer">
                            {c.tokenIdentifier}
                          </a> : c.tokenIdentifier}
                      </td>
                    </tr>;
    })}
              </tbody>
            </table>
          </div>;
  })}
      <p style={{
    fontSize: '0.8em',
    opacity: 0.65,
    marginTop: '8px'
  }}>
        Live from <code>GET https://api.etherfuse.com/lookup/stablebonds</code> — public, no API key required. Each
        address links to that chain's block explorer.
      </p>
    </div>;
};

export const StablebondsTable = () => {
  const {useState, useEffect} = React;
  const [rows, setRows] = useState(null);
  const [error, setError] = useState(null);
  const NAMES = {
    CETES: 'Short-term Mexican government treasury bills',
    USTRY: 'US Treasury bonds',
    TESOURO: 'Brazilian government bonds (Tesouro)',
    GILTS: 'UK government gilts',
    EUROB: 'European sovereign bonds',
    KTB: 'Korean government bonds (Korea Treasury Bonds)'
  };
  useEffect(() => {
    let cancelled = false;
    fetch('https://api.etherfuse.com/lookup/stablebonds').then(r => {
      if (!r.ok) throw new Error('HTTP ' + r.status);
      return r.json();
    }).then(data => {
      if (cancelled) return;
      const bonds = (data.stablebonds || []).filter(b => b.symbol !== 'MEX').sort((a, b) => String(a.symbol).localeCompare(String(b.symbol)));
      setRows(bonds);
    }).catch(e => {
      if (!cancelled) setError(e.message || 'failed to load');
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const fmtRate = (p, ccy) => {
    const n = Number(p);
    if (!isFinite(n)) return String(p);
    return n.toLocaleString('en-US', {
      minimumFractionDigits: 2,
      maximumFractionDigits: 4
    }) + ' ' + (ccy || '');
  };
  const border = '1px solid rgba(128,128,128,0.25)';
  const cell = {
    padding: '8px 12px',
    borderBottom: border,
    textAlign: 'left'
  };
  const head = {
    ...cell,
    fontWeight: 600
  };
  return <div>
      <table style={{
    width: '100%',
    borderCollapse: 'collapse',
    fontSize: '0.95em'
  }}>
        <thead>
          <tr>
            <th style={head}>Symbol</th>
            <th style={head}>Bond</th>
            <th style={head}>Currency</th>
          </tr>
        </thead>
        <tbody>
          {rows && rows.map(b => <tr key={b.symbol}>
                <td style={cell}>
                  <strong>{b.symbol}</strong>
                </td>
                <td style={cell}>{NAMES[b.symbol] || '—'}</td>
                <td style={cell}>{b.bondCurrency}</td>
              </tr>)}
          {!rows && !error && <tr>
              <td style={cell} colSpan={3}>
                Loading live stablebonds…
              </td>
            </tr>}
          {error && <tr>
              <td style={cell} colSpan={3}>
                Couldn't load the live list. See <code>GET /lookup/stablebonds</code>.
              </td>
            </tr>}
        </tbody>
      </table>
      <p style={{
    fontSize: '0.8em',
    opacity: 0.65,
    marginTop: '8px'
  }}>
        Live from <code>GET https://api.etherfuse.com/lookup/stablebonds</code> — public, no API key required.
      </p>
    </div>;
};

## Products & assets

| Term | Meaning |
| - | - |
| **Stablebond** | A tokenized, **yield-bearing** sovereign bond (for example CETES). It earns the yield of the underlying government debt while you hold it on-chain. |
| **Stablecoin** | A token pegged to a fiat currency, such as USDC. |

### Stablebonds

Stablebonds are **yield-bearing**: they accrue the yield of the underlying sovereign debt while you hold them.

<StablebondsTable />

### Token addresses

Each stablebond is deployed on multiple chains, each with its own mint (Solana), asset issuer (Stellar), or token contract (EVM). The addresses below are pulled live and link to each chain's block explorer. Use them to verify a token, add a trustline, or import the asset. When you **quote**, always use the token's `asset` from [`GET /supported_assets`](/v2/api-reference/assets/list-supported-assets) and do not hardcode addresses. Sandbox identifiers differ from these production ones.

<BondMintAccounts />

## Payment accounts

| Term | Meaning |
| - | - |
| **Payment account** | A bank account or a wallet that money moves from or to. You register both with [`POST /organization/{organizationId}/payment_account`](/v2/api-reference/payment-accounts/register-payment-account), and quotes name them by `id`. |
| **Kind** (`kind`) | What sort of account it is: `bank` or `wallet`. The request returns `422` `unsupported` for `debitCard` and `cash`. |
| **Rail** | The network that moves the money: `spei` or `pix` for a bank account, or the chain (`stellar`, `solana`, `base`, `polygon`, `monad`, `avalanche`) for a wallet. |
| **accountDetails** | The identifier that names the account, tagged by its own `kind`: `clabe` (a CLABE), `pixKey` (a Pix key), or `address` (a wallet address plus its `chain`). We do not return it on reads. |
| **registrationInfo** | Account holder details a bank route needs, such as `accountHolderName` and `taxId`. We fill what we can from the verified identity of the organization in the route; a `422` `registration-info-required` lists what you still have to send. |
| **Route readiness** | The account's status on one rail in one direction, under `rails.<rail>.source` (money leaving the account) and `rails.<rail>.destination` (money arriving). Each is `pending`, `ready`, `rejected` or `disabled`, and you can quote a direction only when it is `ready`. A direction is `null` when the rail cannot move money that way. |
| **Default rail** (`isDefault`) | The rail a quote uses for a side when the quote does not name one. |

## Transaction types

| Term | Meaning |
| - | - |
| **Onramp** | Buying tokens with fiat: the customer pays from a bank account and receives tokens in a wallet. |
| **Offramp** | Selling tokens for fiat: the customer sends tokens from a wallet and receives fiat in a bank account. |
| **Swap** | Exchanging one token for another on the same chain. |
| **Cross-chain transfer** | Sending a token from a wallet on one supported chain to a wallet on another. |
| **Quote** | Pricing for a transfer between two payment accounts, from [`POST /organization/{organizationId}/quote`](/v2/api-reference/quotes/create-quote). Create the order before `expiresAt`, 2 minutes after the quote is created. |
| **Order** | A transfer created from a quote with [`POST /organization/{organizationId}/order`](/v2/api-reference/orders/create-order). The order `id` equals the `quoteId`, and sending the same `quoteId` again returns the same order. |
| **Order status** | `created`, `funded`, `claimable`, `completed`, `failed`, `canceled` or `refunded`. |
| **Authorization** | The account holder's approval of a transfer we built, such as an offramp from an embedded wallet. While one is pending, the order's `authorization` holds the `message` to sign, and [`POST /organization/{organizationId}/order/{id}/authorization`](/v2/api-reference/orders/submit-authorization) takes the signature. |
| **Claimable** | The order status after we deliver the funds, while the customer still has to accept them. `claimInstructions` holds what they need, and [`POST /organization/{organizationId}/order/{id}/claim`](/v2/api-reference/orders/prepare-claim) prepares the claim. |
| **Funding instructions** (`fundingInstructions`) | How the source funds an order: the `rail`, our `reference`, the `destination` to pay (a CLABE for SPEI, a BR Code for Pix, an address for a wallet), and the `fundingDeadline`. |

## Fiat & banking (Mexico)

| Term | Meaning |
| - | - |
| **MXN** | Mexican peso. |
| **SPEI** | Mexico's real-time interbank electronic transfer system. |
| **CLABE** | The 18-digit standardized Mexican bank account number used for SPEI transfers. Registered as `accountDetails` of kind `clabe`. |
| **RFC** | Mexican taxpayer ID (Registro Federal de Contribuyentes). Sandbox uses placeholder RFCs such as `XAXX010101000`. See the [Test environment](/v2/test-environment). |

## Fiat & banking (Brazil)

| Term | Meaning |
| - | - |
| **BRL** | Brazilian real, the fiat currency for Brazil ramps. |
| **Pix** | Brazil's instant payment system, operated by the Central Bank of Brazil. The Brazilian equivalent of SPEI. |
| **Pix key** (`pixKey`) | The identifier a Pix payment is sent to: a CPF, CNPJ, email, phone number, or random key. Registered as `accountDetails` of kind `pixKey`. |
| **BR Code** (`brCode`) | The Pix payment code in an order's funding instructions when the source pays over Pix. |
| **CPF** | Brazilian individual taxpayer ID (Cadastro de Pessoas Físicas). The Brazilian analog of Mexico's RFC. |
| **CNPJ** | Brazilian business taxpayer ID (Cadastro Nacional da Pessoa Jurídica). |

## Identity & compliance

| Term | Meaning |
| - | - |
| **KYC** | Know Your Customer: identity verification for an individual (personal customer). |
| **KYB** | Know Your Business: verification of a business entity, such as your organization for production access. |
| **Partner fee** | An additional fee (up to 500 bps) a partner can add on top of the platform fee. It appears as a `partnerFee` line in a quote's `fees`. See [Fees](/v2/fees). |
| **bps** | Basis points. 1 bps = 0.01%; 100 bps = 1%. |

## On-chain

| Term | Meaning |
| - | - |
| **Wallet** | A blockchain address registered as a payment account of kind `wallet`, with `accountDetails` of kind `address` and its `chain`. |
| **Trustline** | *(Stellar)* Authorization a wallet must establish before it can hold a given asset. |
| **XDR** | *(Stellar)* The encoded transaction format a user signs, for example the `xdr` in a claim transaction. |
| **Claimable balance** | *(Stellar)* A pending balance the recipient claims. A `claimable` Stellar order carries one in `claimInstructions` with kind `stellarClaimableBalance`. |
| **Prepared transaction** (`preparedTransaction`) | A transaction we build for the customer to sign and submit when a wallet funds an order. It sits in the funding destination. A Solana or Stellar transaction goes stale after `refreshAfter`; a Stellar or EVM transaction also goes stale when the wallet's sequence number or nonce moves. Refresh the funding instructions to get a new one. |
| **Stellar anchor** | A bridge between the Stellar network and traditional fiat rails, defined by Stellar Ecosystem Proposals (SEPs). Etherfuse acts as an anchor for Stellar offramps. [Learn more ↗](https://developers.stellar.org/docs/learn/fundamentals/anchors) |

## Verification

| Term | Meaning |
| - | - |
| **KYC WebSDK** | The hosted verification flow: you create the customer and launch them, and they complete every step in the widget. See [KYC WebSDK](/v2/guides/kyc-websdk). |
| **KYC API** | Pushing a customer's personal data, documents and questionnaire answers over the API so they aren't asked for them again, then launching them only for what is left. See [KYC API](/v2/guides/kyc-api). |
| **Share token** | A single-use share token created in a partner's own Sumsub account. It hands Etherfuse a verification the customer already passed, so documents *and* liveness transfer. Requires a data-sharing agreement. See [KYC Sumsub Shared Token](/v2/guides/kyc-sumsub-shared-token). |
| **Requirement** | One step in a customer's verification, named by its `type`, with a `status` and a `requiresLaunch` flag that is true when only the customer can satisfy it. Returned by `GET /organization/{organizationId}/kyc?requirements=true`. See [Tracking verification status](/v2/guides/onboarding#tracking-verification-status). |

## Organization & events

| Term | Meaning |
| - | - |
| **Child organization** | A sub-organization you create (and can apply a partner fee to) on behalf of a partner or customer. |
| **organizationId** | The organization a payment account, quote or order call acts for, in the route `/organization/{organizationId}/...`. It is your own organization or one of your direct customer organizations. Any other id returns `404` `not-found`. See [Organizations in the route](/v2/overview#organizations-in-the-route). |
| **Webhook** | An HMAC-signed HTTP callback. Subscribe with [`POST /webhook_subscription`](/v2/api-reference/webhook-subscriptions/create-webhook-subscription) to `orderUpdated`, `paymentAccountUpdated`, `kycUpdated` or `kybUpdated`. See [Webhooks](/v2/webhooks). |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.