assets

name	assets
description	Stellar Assets (classic) + trustlines + Stellar Asset Contract (SAC) bridge to smart contracts. Covers asset issuance, distribution, authorization flags, clawback, regulated assets, trustline management, and the SAC interop layer that exposes classic assets as SEP-41 contract tokens. Use when tokenizing real-world assets, issuing stablecoins, managing trustlines, or bridging classic assets to smart contracts.
user-invocable	true
argument-hint	[asset task]

Stellar Assets, Trustlines, and SAC

Stellar's native token mechanism: classic asset issuance, trustlines, and the Stellar Asset Contract (SAC) bridge that makes classic assets usable from smart contracts. Default to classic assets over custom contract tokens unless you need custom logic.

When to use this skill

• Issuing a new asset (stablecoin, security token, utility token)
• Setting up trustlines from a client or contract
• Managing issuer flags (auth required, auth revocable, clawback)
• Bridging a classic asset into a smart contract via SAC
• Building regulated-asset flows (compliance, KYC, freeze)

Related skills

• Custom token contracts (when classic isn't enough) → ../smart-contracts/SKILL.md
• UI flows for trustline creation and asset display → ../dapp/SKILL.md
• Looking up balances and trustline state → ../data/SKILL.md
• Token-related SEPs (SEP-41, SEP-7, etc.) → ../standards/SKILL.md

---

Overview

Stellar has two token mechanisms:

1. Stellar Assets (Classic): Built-in, highly efficient, full ecosystem support
2. Contract tokens (SEP-41): Custom contracts with flexible logic

Recommendation: Prefer Stellar Assets unless you need custom token logic.

Stellar Assets (Classic)

Asset Types

Type	Description
Native (XLM)	Stellar's native currency, no trustline needed
Credit	Issued by an account, requires trustline
Liquidity Pool Shares	Represent LP positions

Asset Identifiers

import * as StellarSdk from "@stellar/stellar-sdk";

// Native XLM
const xlm = StellarSdk.Asset.native();

// Credit asset (code + issuer)
const usdc = new StellarSdk.Asset(
  "USDC",
  "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"
);

// Asset code rules:
// - 1-4 chars: alphanumeric (credit_alphanum4)
// - 5-12 chars: alphanumeric (credit_alphanum12)

Issuing Assets

Create Issuing Account

import * as StellarSdk from "@stellar/stellar-sdk";

const server = new StellarSdk.Horizon.Server("https://horizon-testnet.stellar.org");

// 1. Create issuing account (should be separate from distribution)
const issuerKeypair = StellarSdk.Keypair.random();
const distributorKeypair = StellarSdk.Keypair.random();

// 2. Fund accounts (testnet)
await fetch(`https://friendbot.stellar.org?addr=${issuerKeypair.publicKey()}`);
await fetch(`https://friendbot.stellar.org?addr=${distributorKeypair.publicKey()}`);

Issue Asset

const asset = new StellarSdk.Asset("MYTOKEN", issuerKeypair.publicKey());

// 1. Distributor creates trustline to issuer
const distributorAccount = await server.loadAccount(distributorKeypair.publicKey());

const trustlineTx = new StellarSdk.TransactionBuilder(distributorAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.changeTrust({
      asset: asset,
      limit: "1000000", // Max amount to hold
    })
  )
  .setTimeout(180)
  .build();

trustlineTx.sign(distributorKeypair);
await server.submitTransaction(trustlineTx);

// 2. Issuer sends tokens to distributor
const issuerAccount = await server.loadAccount(issuerKeypair.publicKey());

const issueTx = new StellarSdk.TransactionBuilder(issuerAccount, {
  fee: StellarSdk.,
  : ..,
})
  .(
    ..({
      : distributorKeypair.(),
      : asset,
      : ,
    })
  )
  .()
  .();

issueTx.(issuerKeypair);
 server.(issueTx);

Lock Issuing Account

For fixed-supply tokens, lock the issuer:

const lockTx = new StellarSdk.TransactionBuilder(issuerAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.setOptions({
      masterWeight: 0, // Disable master key
    })
  )
  .setTimeout(180)
  .build();

lockTx.sign(issuerKeypair);
await server.submitTransaction(lockTx);
// Issuer can never issue more tokens

Asset Flags

Configure issuer account flags for compliance:

const setFlagsTx = new StellarSdk.TransactionBuilder(issuerAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.setOptions({
      setFlags:
        StellarSdk.AuthRequiredFlag |    // Trustlines require approval
        StellarSdk.AuthRevocableFlag |   // Can freeze trustlines
        StellarSdk.AuthClawbackEnabledFlag, // Can clawback tokens
    })
  )
  .setTimeout(180)
  .build();

Flag Descriptions

Flag	Effect
AUTH_REQUIRED	Users must get approval before receiving tokens
AUTH_REVOCABLE	Issuer can freeze user balances
AUTH_IMMUTABLE	Flags cannot be changed (permanent)
AUTH_CLAWBACK_ENABLED	Issuer can clawback tokens from accounts

Authorize Trustline

// When AUTH_REQUIRED is set, approve trustlines:
const authorizeTx = new StellarSdk.TransactionBuilder(issuerAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.setTrustLineFlags({
      trustor: userPublicKey,
      asset: asset,
      flags: {
        authorized: true,
        // authorizedToMaintainLiabilities: true, // Partial auth
      },
    })
  )
  .setTimeout(180)
  .build();

Clawback Tokens

// Requires AUTH_CLAWBACK_ENABLED flag
const clawbackTx = new StellarSdk.TransactionBuilder(issuerAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.clawback({
      asset: asset,
      from: targetAccountId,
      amount: "100",
    })
  )
  .setTimeout(180)
  .build();

Trustlines

Create Trustline

const changeTrustTx = new StellarSdk.TransactionBuilder(userAccount, {
  fee: StellarSdk.BASE_FEE,
  networkPassphrase: StellarSdk.Networks.TESTNET,
})
  .addOperation(
    StellarSdk.Operation.changeTrust({
      asset: asset,
      limit: "10000", // Max amount to hold (see "Remove Trustline" for limit: "0")
    })
  )
  .setTimeout(180)
  .build();

Remove Trustline

ChangeTrust with limit: "0" deletes a trustline, but only if the trustline is in a deletable state. Before submitting:

1. Identify the asset by code AND issuer. A wallet-display entry or a claimable balance is not a trustline — only an actual classic asset trustline (or liquidity pool share) on the account can be removed with ChangeTrust. Claimable balances are removed by claiming or clawing them back, not by ChangeTrust.
2. Clear the balance. The trustline balance must be exactly 0 — send remaining funds back to the issuer (burns them) or to another account.
3. Clear offers / buying liabilities. Open DEX offers that buy the asset create buying liabilities; cancel them before removal (manageSellOffer with amount: "0", manageBuyOffer with buyAmount: "0").
4. Exit liquidity pool positions. An asset trustline referenced by a liquidity pool (liquidity_pool_use_count > 0, per CAP-0038) cannot be deleted — withdraw from the pool and remove the pool-share trustline first.

// 1. Check the trustline is deletable
const account = await server.loadAccount(userPublicKey);
const trustline = account.balances.find(
  (b) =>
    b.asset_type !== "native" &&
    b.asset_type !== "liquidity_pool_shares" &&
    b.asset_code === asset.getCode() &&
    b.asset_issuer === asset.getIssuer()
);

if (!trustline) throw new Error("No trustline (display/claimable state only?)");
if (parseFloat(trustline.balance) !== 0)
  throw new Error("Balance must be 0 — send funds away or back to issuer");
if (parseFloat(trustline.buying_liabilities) !== 0)
  throw new Error("Cancel open offers buying this asset first");

// Liquidity-pool usage (precondition 4) is not visible on this balance line —
// if the asset is still in one of the account's pools, the submit below fails
// with op_cannot_delete. Withdraw and remove the pool-share trustline first.

// 2. Submit removal and surface the specific result code
const removeTrustTx = new StellarSdk.(account, {
  : .,
  : ..,
})
  .(
    ..({
      : asset,
      : , 
    })
  )
  .()
  .();

removeTrustTx.(userKeypair);

 {
   server.(removeTrustTx);
}  (e) {
   codes = e.?.?.?.?. ?? [];
   (codes.()) {
    
      ();
  }
   (codes.()) {
    
      ();
  }
   e;
}

Check Trustline Status

const account = await server.loadAccount(userPublicKey);
const trustline = account.balances.find(
  (b) =>
    b.asset_type !== "native" &&
    b.asset_code === "USDC" &&
    b.asset_issuer === usdcIssuer
);

if (trustline) {
  console.log("Balance:", trustline.balance);
  console.log("Limit:", trustline.limit);
  console.log("Authorized:", trustline.is_authorized);
}

Stellar Asset Contract (SAC)

SAC provides a smart-contract interface for Stellar Assets, enabling smart contract interactions.

Deploy SAC for Existing Asset

# Get the SAC address for an asset
stellar contract asset deploy \
  --asset USDC:GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN \
  --source-account alice \
  --network testnet

SAC Address Derivation

import * as StellarSdk from "@stellar/stellar-sdk";

const asset = new StellarSdk.Asset("USDC", issuerPublicKey);
const contractId = asset.contractId(StellarSdk.Networks.TESTNET);
// Returns the deterministic SAC contract address

Using SAC in Smart Contracts

use soroban_sdk::{token::Client as TokenClient, Address, Env};

pub fn transfer_asset(
    env: Env,
    from: Address,
    to: Address,
    asset_contract: Address,
    amount: i128,
) {
    from.require_auth();

    // Use standard token interface
    let token = TokenClient::new(&env, &asset_contract);
    token.transfer(&from, &to, &amount);
}

SAC vs Custom Token Interface

SAC implements the standard SEP-41 token interface:

• balance(id: Address) -> i128
• transfer(from: Address, to: Address, amount: i128)
• approve(from: Address, spender: Address, amount: i128, expiration_ledger: u32)
• allowance(from: Address, spender: Address) -> i128
• decimals() -> u32
• name() -> String
• symbol() -> Symbol

When to Use What

Use Stellar Assets When:

• Standard fungible token (currency, stablecoin)
• Need full ecosystem support (wallets, exchanges)
• Regulatory compliance features (freeze, clawback)
• Performance critical (classic operations are cheaper)
• DEX integration via order book

Use Custom Contract Tokens When:

• Complex transfer logic (royalties, fees, restrictions)
• Custom authorization schemes
• Non-standard token behaviors
• Integration with custom DeFi contracts
• NFTs or semi-fungible tokens

Reach for a fully custom token as a last resort. Many of the cases above (royalties, fees, transfer restrictions) can be built with a regular issued Stellar asset plus a thin "SAC admin" contract that drives the SAC's mint, burn, and clawback functions. That keeps the ecosystem compatibility of a normal asset (DEX, anchors, wallets, trustlines) while still layering on custom logic. Prefer a custom contract token only when you need token behavior the SAC genuinely cannot express.

Use SAC When:

• Need a Stellar asset inside a smart contract
• Building DeFi protocols with existing assets
• Bridge between classic and smart contract operations

Querying Assets

Get Account Balances

const account = await server.loadAccount(publicKey);

for (const balance of account.balances) {
  if (balance.asset_type === "native") {
    console.log("XLM:", balance.balance);
  } else {
    console.log(`${balance.asset_code}:`, balance.balance);
  }
}

Find Assets

// Search for assets by code
const assets = await server
  .assets()
  .forCode("USDC")
  .call();

// Get specific asset details
const assetDetails = await server
  .assets()
  .forCode("USDC")
  .forIssuer(issuerPublicKey)
  .call();

Get Asset Statistics

const stats = await server
  .assets()
  .forCode("USDC")
  .forIssuer(issuerPublicKey)
  .call();

// stats includes:
// - amount: total issued
// - num_accounts: trustline count
// - flags: issuer flags

SEP Standards for Assets

SEP-0001 (stellar.toml)

Publish asset metadata in your domain's /.well-known/stellar.toml:

[[CURRENCIES]]
code = "MYTOKEN"
issuer = "GABC..."
display_decimals = 2
name = "My Token"
desc = "A description of my token"
image = "https://example.com/token-logo.png"

SEP-0010 (Web Authentication)

Authenticate users with their Stellar accounts. Flow: the server generates a challenge transaction, the client signs it with their wallet, and the server verifies the signature. See SEP-0010.

SEP-0024 (Hosted Deposit/Withdrawal)

For fiat on/off ramps: an interactive webview flow where the anchor handles KYC and the fiat transfer. See SEP-0024.

SEP-0045 (Web Auth for Contract Accounts)

Extends SEP-10 to support contract accounts (C... addresses) for web authentication. Required for smart wallet / passkey-based anchor integrations. Draft status; verify current status in SEP-0045.

SEP-0050 (Non-Fungible Tokens)

Standard contract interface for NFTs on Stellar. Reference implementations available in OpenZeppelin Stellar Contracts with Base, Consecutive, and Enumerable variants. Draft status; verify current status in SEP-0050.

Best Practices

Asset Issuance

• Use separate issuing and distribution accounts
• Lock issuer after initial distribution for fixed supply
• Publish stellar.toml with asset metadata
• Consider multisig for issuer account

Trustline Management

• Check trustline exists before sending payments
• Handle trustline creation in onboarding flow
• Respect trustline limits
• Monitor for frozen/deauthorized status
• Before removing a trustline (limit: "0"): zero the balance, cancel offers buying the asset, and exit liquidity pools that reference it

Security

• Validate asset issuer, not just code
• Be cautious of assets with clawback enabled
• Verify stellar.toml from authoritative source
• Use well-known asset lists for common tokens