Stellar

https://github.com/stellar/stellar-docs
Admin
Official documentation and API reference for the Stellar network, built with Docusaurus and written...
Tokens:1,362,258
Snippets:9,029
Trust Score:9.4
License:Apache-2.0
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Run the setup wizard

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/stellar-disbursement-platform/admin-guide/getting-started.mdx

Runs the setup wizard that generates and funds the SEP-10 signer and distribution accounts on testnet, starts Docker, and prints tenant credentials.

```bash
make setup
```

--------------------------------

### Setup wizard prompts

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/stellar-disbursement-platform/admin-guide/getting-started.mdx

Example wizard prompts and responses for the `make setup` command. Choose these options to create a new testnet single-tenant configuration with generated accounts and launch the local environment.

```text
? Select an existing run configuration or create new:
▸ Create new configuration
✔ Setup name (optional): <sdp-setup-name>
? Select network:
▸ testnet
? Select tenant mode:
▸ single-tenant
? Account setup:
▸ Generate new accounts
? Launch local environment now (project=sdp-sdp-test, setup=<sdp-setup-name>)? [Y/n] Y
? Initialize tenants and users? [y/N] Y
```

--------------------------------

### Start Quickstart for testnet with Stellar CLI

Source: https://github.com/stellar/stellar-docs/blob/main/docs/tools/lab/quickstart-with-lab.mdx

Starts the Quickstart Docker container for the testnet network. The container bundles Stellar Core, Horizon, RPC, Friendbot, and PostgreSQL databases. After starting, Quickstart is typically available at http://localhost:8000.

```sh
stellar container start testnet
```

--------------------------------

### Install npm packages

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/agentic-payments/x402/quickstart-guide.mdx

Installs all npm packages required for both the server and client examples in this guide.

```bash
npm install express dotenv @stellar/stellar-sdk @x402/core @x402/express @x402/fetch @x402/stellar
```

--------------------------------

### Initialize Node.js project

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/agentic-payments/x402/quickstart-guide.mdx

Initializes a new Node.js project for the x402 quickstart guide. The `type=module` setting enables the `import` syntax used in the example files.

```bash
mkdir x402-quickstart-guide
cd x402-quickstart-guide
npm init -y
npm pkg set type=module
```

--------------------------------

### Run Quickstart with --testnet (foreground)

Source: https://github.com/stellar/stellar-docs/blob/main/docs/tools/quickstart/advanced-usage/run-command-examples.mdx

Starts an ephemeral testnet node in the foreground. The container is removed on exit (--rm) and runs interactively (-it). Port 8000 is mapped to the host.

```sh
docker run --rm -it \
  -p "8000:8000" \
  --name stellar \
  stellar/quickstart \
  --testnet
```

```powershell
docker run --rm -it `
  -p "8000:8000" `
  --name stellar `
  stellar/quickstart `
  --testnet
```

--------------------------------

### Run Quickstart with persistent volume (--testnet)

Source: https://github.com/stellar/stellar-docs/blob/main/docs/tools/quickstart/advanced-usage/run-command-examples.mdx

Starts a new persistent node using the host directory '/str' mounted to '/opt/stellar' inside the container. Runs in the foreground with --rm and -it flags.

```sh
docker run -it --rm \
  -p "8000:8000" \
  -v "/str:/opt/stellar" \
  --name stellar \
  stellar/quickstart \
  --testnet
```

```powershell
docker run -it --rm `
  -p "8000:8000" `
  -v "/str:/opt/stellar" `
  --name stellar `
  stellar/quickstart `
  --testnet
```

--------------------------------

### Install Node dependencies and set up environment variables

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/smart-contracts/getting-started/hello-world-frontend.mdx

Installs Node dependencies and sets up environment variables. Requires Node.js to be installed. The commands change to the project directory, install frontend dependencies with npm, and copy the example environment file to your own .env.

```sh
cd <my-project> # make sure you're in your new project's directory
npm install # install frontend dependencies
cp .env.example .env # copies the example frontend environment variable file to your own copy
```

--------------------------------

### Run Quickstart with --local (ephemeral)

Source: https://github.com/stellar/stellar-docs/blob/main/docs/tools/quickstart/advanced-usage/run-command-examples.mdx

Starts an ephemeral local-only dev/test network in the background. The container is named 'stellar' and port 8000 is mapped to the host. Use the macOS/Linux (sh) or Windows PowerShell variant depending on your platform.

```sh
docker run -d \
  -p "8000:8000" \
  --name stellar \
  stellar/quickstart \
  --local
```

```powershell
docker run -d `
  -p "8000:8000" `
  --name stellar `
  stellar/quickstart `
  --local
```

--------------------------------

### Stellar SDK Muxed Account Payment Examples

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/pooled-accounts-muxed-accounts-memos.mdx

Complete JavaScript example using Stellar SDK to demonstrate payments between G and M accounts. It includes setup, three payment examples, and helper functions. Run all examples with `runAllMuxedExamples()` or individual functions.

```javascript
import * as sdk from "@stellar/stellar-sdk";

const server = new sdk.rpc.Server("https://soroban-testnet.stellar.org");

const custodian = sdk.Keypair.random();
const outsider = sdk.Keypair.random();

let custodianAcc, outsiderAcc, customers;

// Setup function to fund accounts and create muxed customers
async function preamble() {
  console.log("=== FUNDING ACCOUNTS WITH XLM ===");
  await Promise.all([
    server.requestAirdrop(custodian.publicKey()),
    server.requestAirdrop(outsider.publicKey()),
  ]);
  console.log("All accounts funded with XLM via airdrop");

  [custodianAcc, outsiderAcc] = await Promise.all([
    server.getAccount(custodian.publicKey()),
    server.getAccount(outsider.publicKey()),
  ]);

  customers = ["1", "22", "333", "4444"].map(
    (id) => new sdk.MuxedAccount(custodianAcc, id),
  );

  console.log("\n=== ACCOUNT SETUP ===");
  console.log("Custodian:\n       ", custodian.publicKey());
  console.log("Outsider:\n       ", outsider.publicKey());
  console.log("Customers:");
  customers.forEach((customer) => {
    console.log(
      " " + customer.id().padStart(4, " ") + ":",
      customer.accountId(),
    );
  });
}

// Example 1: Basic payment between two G accounts
async function runUnmuxedExample() {
  console.log("=== BASIC PAYMENT EXAMPLE (G → G) ===");

  console.log("=== INITIAL BALANCES ===");
  await showBalance(custodianAcc);
  await showBalance(outsiderAcc);

  await makePayment(
    custodianAcc,
    outsiderAcc,
    "Basic Payment from G to G address",
  );

  console.log("\n=== FINAL BALANCES ===");
  const finalCustodianAcc = await server.getAccount(custodian.publicKey());
  const finalOutsiderAcc = await server.getAccount(outsider.publicKey());
  await showBalance(finalCustodianAcc);
  await showBalance(finalOutsiderAcc);

  console.log("\n=== BASIC PAYMENT EXAMPLE COMPLETED ===");
}

// Example 2: Payment from M account to G account
async function runMuxedToUnmuxedExample() {
  console.log("=== MUXED TO UNMUXED PAYMENT EXAMPLE (M → G) ===");

  console.log("=== INITIAL BALANCES ===");
  await showBalance(custodianAcc);
  await showBalance(outsiderAcc);
  const src = customers[0];
  console.log(
    `Sending 10 XLM from Customer ${src.id()} to ${formatAccount(
      outsiderAcc.accountId(),
    )}.`,
  );

  await makePayment(src, outsiderAcc, "Payment from M to G address");

  console.log("\n=== FINAL BALANCES ===");
  const finalCustodianAcc = await server.getAccount(custodian.publicKey());
  const finalOutsiderAcc = await server.getAccount(outsider.publicKey());
  await showBalance(finalCustodianAcc);
  await showBalance(finalOutsiderAcc);

  console.log("\n=== MUXED TO UNMUXED EXAMPLE COMPLETED ===");
}

// Example 3: Payment between two M accounts
async function runMuxedToMuxedExample() {
  console.log("=== MUXED TO MUXED PAYMENT EXAMPLE (M → M) ===");

  console.log("=== INITIAL BALANCES ===");
  await showBalance(custodianAcc);

  const src = customers[1]; // Customer 22
  const dest = customers[2]; // Customer 333

  console.log(
    `Sending 10 XLM from Customer ${src.id()} to Customer ${dest.id()}.`,
  );

  await makePayment(src, dest, "Payment from M to M address");

  console.log("\n=== FINAL BALANCES ===");
  const finalCustodianAcc = await server.getAccount(custodian.publicKey());
  await showBalance(finalCustodianAcc);

  console.log("\n=== MUXED TO MUXED EXAMPLE COMPLETED ===");
}

// Main function that runs preamble once and then all three examples
async function runAllMuxedExamples() {
  try {
    // Run setup/funding only once
    await preamble();

    // Show initial state
    console.log("=== OVERALL INITIAL BALANCES ===");
    await showBalance(custodianAcc);
    await showBalance(outsiderAcc);
    console.log("\n" + "=".repeat(60) + "\n");

    // Run all three examples sequentially
    await runUnmuxedExample();
    console.log("\n" + "=".repeat(60) + "\n");

    await runMuxedToUnmuxedExample();
    console.log("\n" + "=".repeat(60) + "\n");

    await runMuxedToMuxedExample();

    console.log("\n=== ALL MUXED ACCOUNT EXAMPLES COMPLETED ===");
  } catch (error) {
    console.error("Error in examples:", error.message);
  }
}

// Helper function to format account ID with label
function formatAccount(accountId) {
  const shortId = accountId.substring(0, 8);
  if (accountId === custodian.publicKey()) {
    return `${shortId} (Custodian)`;
  } else if (accountId === outsider.publicKey()) {
    return `${shortId} (Outsider)`;
  }
}
```

--------------------------------

### Run MPP server

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/agentic-payments/mpp/charge-guide.mdx

Starts the MPP server example with placeholder environment variables. replace `GYOUR_PUBLIC_KEY` with your Stellar public key and set a strong secret for `MPP_SECRET_KEY`.

```bash
STELLAR_RECIPIENT=GYOUR_PUBLIC_KEY MPP_SECRET_KEY=replace-me node server.js
```

--------------------------------

### Run Quickstart with --enable-core-manual-close

Source: https://github.com/stellar/stellar-docs/blob/main/docs/tools/quickstart/advanced-usage/run-command-examples.mdx

Starts an ephemeral local network with manual ledger close enabled. Ledgers only advance when you send the 'manualclose' command to stellar-core's HTTP endpoint (see Operation Modes).

```sh
docker run -d \
  -p "8000:8000" \
  -p "127.0.0.1:11626:11626" \
  --name stellar \
  stellar/quickstart \
  --local \
  --enable-core-manual-close
```

```powershell
docker run -d `
  -p "8000:8000" `
  -p "127.0.0.1:11626:11626" `
  --name stellar `
  stellar/quickstart `
  --local `
  --enable-core-manual-close
```

--------------------------------

### Clone and navigate to the deployer example

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/conventions/deploy-contract.mdx

Clones the Soroban Examples repository and navigates to the deployer example directory. These commands are the first steps to set up the environment for the deployer contract example.

```bash
git clone -b main https://github.com/stellar/soroban-examples
```

```bash
cd soroban-examples/deployer/deployer
```

--------------------------------

### Setup helper functions for clawback examples

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/clawbacks.mdx

Helper functions for clawback examples: creates three random accounts (A, B, C), defines a CLAW asset, and provides utilities to fund accounts via airdrop, enable clawback flags (AuthClawbackEnabledFlag | AuthRevocableFlag), establish trustlines with a limit of 5000, and fetch claimable balance details using the SDK's getClaimableBalance method. Uses the Soroban testnet server at https://soroban-testnet.stellar.org.

```javascript
import * as sdk from "@stellar/stellar-sdk";

let server = new sdk.rpc.Server("https://soroban-testnet.stellar.org");

const A = sdk.Keypair.random();
const B = sdk.Keypair.random();
const C = sdk.Keypair.random();

console.log("=== ACCOUNT SETUP ===");
console.log(`Account A (Issuer): ${A.publicKey()}`);
console.log(`Account B (Trustor): ${B.publicKey()}`);
console.log(`Account C (Trustor): ${C.publicKey()}`);
console.log();

const ASSET = new sdk.Asset("CLAW", A.publicKey());

// Helper function to format account ID with label
function formatAccount(accountId) {
  const shortId = accountId.substring(0, 8);
  if (accountId === A.publicKey()) {
    return `${shortId} (Account A)`;
  } else if (accountId === B.publicKey()) {
    return `${shortId} (Account B)`;
  } else if (accountId === C.publicKey()) {
    return `${shortId} (Account C)`;
  }
  return shortId;
}

// Helper function to safely scale XDR Int64 asset amounts
function scaleAsset(x) {
  return Number((x * 10n) / 10000000n) / 10; // one decimal place
}

// Helper function to fetch claimable balance details using SDK's built-in method
async function fetchClaimableBalance(
  balanceId,
  description = "Claimable Balance",
) {
  try {
    console.log(`\n--- Checking ${description} ---`);
    console.log(`Looking up balance ID: ${balanceId}`);

    // Use SDK's built-in getClaimableBalance method
    const claimableBalance = await server.getClaimableBalance(balanceId);
    const asset = sdk.Asset.fromOperation(claimableBalance.asset());
    const amount = scaleAsset(claimableBalance.amount().toBigInt()).toFixed(1);

    console.log(`✅ Found claimable balance`);
    console.log(`   Amount: ${amount} ${asset.code}`);
    console.log(
      `   Number of claimants: ${claimableBalance.claimants().length}`,
    );

    // Show claimant details
    claimableBalance.claimants().forEach((claimant, index) => {
      const destination = claimant.v0().destination().ed25519();
      const claimantAddress = sdk.StrKey.encodeEd25519PublicKey(destination);
      console.log(
        `   Claimant ${index + 1}: ${formatAccount(claimantAddress)}`,
      );
    });

    return true; // Balance exists
  } catch (error) {
    console.log(`❌ Claimable balance not found (${error.message})`);
    return false; // Balance doesn't exist
  }
}

// Fund accounts first
function fundAccounts() {
  console.log("=== FUNDING ACCOUNTS WITH XLM ===");
  return Promise.all([
    server.requestAirdrop(A.publicKey()),
    server.requestAirdrop(B.publicKey()),
    server.requestAirdrop(C.publicKey()),
  ]).then(() => {
    console.log("All accounts funded with XLM via airdrop");
    // Wait for funding to complete
    return new Promise((resolve) => setTimeout(resolve, 3000));
  });
}

// Enables AuthClawbackEnabledFlag on an account.
function enableClawback(account, keys) {
  console.log(
    `Enabling clawback flags on account ${formatAccount(account.accountId())}`,
  );
  return submitAndPollTransaction(
    buildTx(account, keys, [
      sdk.Operation.setOptions({
        setFlags: sdk.AuthClawbackEnabledFlag | sdk.AuthRevocableFlag,
      }),
    ]),
    "Enable Clawback Flags",
  );
}

// Establishes a trustline for `recipient` for the CLAW Asset
const establishTrustline = function (recipient, key) {
  console.log(
    `${formatAccount(recipient.accountId())} establishing trustline for ${
      ASSET.code
    }`,
  );
  return submitAndPollTransaction(
    buildTx(recipient, key, [
      sdk.Operation.changeTrust({
        asset: ASSET,
        limit: "5000", // arbitrary
      }),
    ]),
    `Establish Trustline (${formatAccount(recipient.accountId())})`,
  );
};
```

--------------------------------

### Clone and run the development server

Source: https://github.com/stellar/stellar-docs/blob/main/README.md

Clones the repository, installs dependencies with pnpm, and starts the development server. The server opens a browser at http://localhost:3000/docs/ and auto-reloads on changes. If you previously used Yarn, delete the old node_modules directory before running pnpm install to avoid failures.

```bash
git clone https://github.com/stellar/stellar-docs
cd stellar-docs
pnpm install
pnpm start
```

--------------------------------

### Run local standalone network with Docker Quickstart

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/apis/rpc/admin-guide/development.mdx

Starts a local standalone Stellar network using the stellar/quickstart:testing Docker image with RPC enabled on port 8000. The --rm flag removes the container when stopped.

```bash
docker run --rm -it \
    -p 8000:8000 \
    --name stellar \
    stellar/quickstart:testing \
    --local \
    --enable-stellar-rpc
```

--------------------------------

### Automate Setup: Create Account, Issue Asset, Create Liquidity Pool, Deploy Contract

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/basics/automate-reset-data.mdx

Defines asynchronous functions to automate Stellar testnet setup: createAccount funds a new account via FriendBot, issueAsset sets up a trust line and issues a custom asset, createLiquidityPool creates a pool and deposits liquidity, deployAndInvokeContract uploads Wasm and invokes the contract, and automateSetup orchestrates the flow. Uses helper functions sleep and submitTx (submitTx is outlined in another guide).

```javascript
console.log("Contract ID:", ContractData.contractId);
console.log("Return Values:", ContractData.returnValues.join(", "));
  } catch (error) {
    console.error("An error occurred:", error);
  }
}

automateSetup();
```

--------------------------------

### Get --help Anywhere for stellar-core Commands

Source: https://github.com/stellar/stellar-docs/blob/main/docs/validators/admin-guide/commands.mdx

Shows how to use the --help option (aliases: -h or -?) at any place in the command line to display help for the relevant command. Examples cover the top-level help, the run command, the new-db command, and the catchup command.

```bash
sudo -u stellar stellar-core --conf /etc/stellar/stellar-core.cfg --help
sudo -u stellar stellar-core --conf /etc/stellar/stellar-core.cfg run --help
sudo -u stellar stellar-core --conf /etc/stellar/stellar-core.cfg --help new-db
sudo -u stellar stellar-core --conf /etc/stellar/stellar-core.cfg catchup --help
```

--------------------------------

### Install MPP packages

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/agentic-payments/mpp/charge-guide.mdx

Installs the npm packages required for the MPP server and client examples in this guide.

```bash
npm install express @stellar/mpp mppx @stellar/stellar-sdk
```

--------------------------------

### Simulate liquidity pool participation with deposits, withdrawals, and spot price checks

Source: https://github.com/stellar/stellar-docs/blob/main/docs/learn/fundamentals/liquidity-on-stellar-sdex-liquidity-pools.mdx

This example combines account setup, trustline establishment, liquidity deposits, and a full withdrawal to simulate pool participation. It maintains a 1:3 deposit ratio and prints the spot price after each step. The JavaScript version uses Promise chains and the Python version uses a sequential flow with Decimal for precision.

```JavaScript
function main() {
  return getAccounts()
    .then((accounts) => {
      return Promise.all(
        kps.map((kp, i) => {
          const acc = accounts[i];
          const depositA = ((i + 1) * 1000).toString();
          const depositB = ((i + 1) * 3000).toString(); // maintain a 1:3 ratio

          return establishPoolTrustline(acc, kp, poolShareAsset)
            .then(() => addLiquidity(acc, kp, poolId, depositA, depositB))
            .then(() => getSpotPrice());
        }),
      ).then(() => accounts);
    })
    .then((accounts) => {
      // kp1 takes all his/her shares out
      return server
        .accounts()
        .accountId(kps[1].publicKey())
        .call()
        .then(({ balances }) => {
          let balance = 0;
          balances.every((bal) => {
            if (
              bal.asset_type === "liquidity_pool_shares" &&
              bal.liquidity_pool_id === poolId
            ) {
              balance = bal.balance;
              return false;
            }
            return true;
          });
          return balance;
        })
        .then((balance) =>
          removeLiquidity(accounts[1], kps[1], poolId, balance),
        );
    })
    .then(() => getSpotPrice());
}

function getSpotPrice() {
  return server
    .liquidityPools()
    .liquidityPoolId(poolId)
    .call()
    .then((pool) => {
      const [a, b] = pool.reserves.map((r) => r.amount);
      const spotPrice = new BigNumber(a).div(b);
      console.log(`Price: ${a}/${b} = ${spotPrice.toFormat(2)}`);
    });
}

preamble().then(main);
```

```Python
def main():
    deposit_a = Decimal(1000)
    deposit_b = Decimal(3000)  # maintain a 1:3 ratio
    establish_pool_trustline(kps[1], pool_share_asset)
    add_liquidity(kps[1], pool_id, deposit_a, deposit_b)
    get_spot_price()

    deposit_a = Decimal(2000)
    deposit_b = Decimal(6000)  # maintain a 1:3 ratio
    establish_pool_trustline(kps[2], pool_share_asset)
    add_liquidity(kps[2], pool_id, deposit_a, deposit_b)
    get_spot_price()

    # kp1 takes all his/her shares out
    balance = 0
    for b in server.accounts().account_id(kps[1].public_key).call()["balances"]:
        if (
                b["asset_type"] == "liquidity_pool_shares"
                and b["liquidity_pool_id"] == pool_id
        ):
            balance = Decimal(b["balance"])
            break
    if not balance:
        raise
    remove_liquidity(kps[1], pool_id, balance)
    get_spot_price()

def get_spot_price():
    resp = server.liquidity_pools().liquidity_pool(pool_id).call()
    amount_a = resp["reserves"][0]["amount"]
    amount_b = resp["reserves"][1]["amount"]
    spot_price = Decimal(amount_a) / Decimal(amount_b)
    print(f"Price: {amount_a}/{amount_b} = {spot_price:.7f}")

if __name__ == '__main__':
    preamble()
    main()
```

--------------------------------

### quickstart.sh script for Docker deployment

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/dapps/docker.mdx

A wrapper script for the `stellar/quickstart` Docker image. It sets up the Docker environment for running the dapp, allowing you to choose between a standalone network or the Futurenet network. The script creates the `soroban-network` Docker network, removes any existing `soroban-preview` container, runs the `soroban-preview` container, and then runs the `stellar/quickstart` image with the chosen network type and Stellar RPC enabled.

```bash
#!/bin/bash

set -e

case "$1" in
standalone)
    echo "Using standalone network"
    ARGS="--standalone"
    ;;
futurenet)
    echo "Using Futurenet network"
    ARGS="--futurenet"
    ;;
*)
    echo "Usage: $0 standalone|futurenet"
    exit 1
    ;;
esac

shift

# Run the soroban-preview container
# Remember to do:
# make build-docker

echo "Creating docker soroban network"
(docker network inspect soroban-network -f '{{.Id}}' 2>/dev/null) \
  || docker network create soroban-network

echo "Searching for a previous soroban-preview docker container"
containerID=$(docker ps --filter="name=soroban-preview" --all --quiet)
if [[ ${containerID} ]]; then
    echo "Start removing soroban-preview container."
    docker rm --force soroban-preview
    echo "Finished removing soroban-preview container."
else
    echo "No previous soroban-preview container was found"
fi

currentDir=$(pwd)
docker run -dti \
  --volume ${currentDir}:/workspace \
  --name soroban-preview \
  -p 8001:8000 \
  --ipc=host \
  --network soroban-network \
  soroban-preview:11

# Run the stellar quickstart image

docker run --rm -ti \
  --name stellar \
  --network soroban-network \
  -p 8000:8000 \
  stellar/quickstart:testing \
  $ARGS \
  --enable-soroban-rpc \
  "$@" # Pass through args from the CLI
```

--------------------------------

### stellar-disbursement-platform db setup-for-network examples

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/stellar-disbursement-platform/admin-guide/cli-manual.mdx

Provides two example invocations: one for a specific tenant using `--tenant-id` and one for all tenants using `--all`. The `--all` flag is ignored if `--tenant-id` is set.

```bash
# Setup for a specific tenant
stellar-disbursement-platform db setup-for-network --tenant-id <tenant-id>

# Setup for all tenants
stellar-disbursement-platform db setup-for-network --all
```

--------------------------------

### Bash: Install rustfmt with cargo

Source: https://github.com/stellar/stellar-docs/blob/main/docs/learn/migrate/evm/solidity-and-rust-advanced-concepts.mdx

Run this command to install the rustfmt tool, which automatically formats Rust code according to the Rust style guide.

```bash
cargo install rustfmt
```

--------------------------------

### JavaScript: Initialize project and install dependencies

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/upload-wasm-bytecode.mdx

Creates a Node.js project and installs the Stellar SDK and file system module.

```bash
touch index.js
npm init es6 -y
npm install @stellar/stellar-sdk fs
```

--------------------------------

### Stop Services with docker-compose down

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/admin-guide/getting-started.mdx

Stops all services started by the quick-run setup.

```bash
docker-compose down
```

--------------------------------

### Go: Create Account Full Example

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/create-account.mdx

Complete Go example using the go-stellar-sdk to generate a keypair, fund it via friendbot, create a child account with CreateAccount, and fetch native and USDC balances. Requires a Soroban RPC server and testnet USDC issuer.

```go
package main

import (
  "context"
  "fmt"
  "io"
  "log"
  "net/http"
  "net/url"
  "strings"
  "time"

  "github.com/stellar/go-stellar-sdk/amount"
  "github.com/stellar/go-stellar-sdk/keypair"
  "github.com/stellar/go-stellar-sdk/network"
  "github.com/stellar/go-stellar-sdk/txnbuild"
  "github.com/stellar/go-stellar-sdk/xdr"

  client "github.com/stellar/go-stellar-sdk/clients/rpcclient"
  protocol "github.com/stellar/go-stellar-sdk/protocols/rpc"
)

const (
  rpcURL            = "https://soroban-testnet.stellar.org"
  testnetUSDCIssuer = "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5"
  pollAttempts      = 10
  pollInitialDelay  = time.Second
)

func main() {
  //
  // Generating keypairs
  //
  parent := keypair.MustRandom()
  log.Printf("Secret: %s", parent.Seed())
  log.Printf("Public: %s", parent.Address())
```

--------------------------------

### GET /customer request by customer ID

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/sep-guide/sep31/integration.mdx

Example GET /customer request URL that identifies a customer using the previously returned customer ID and customer type.

```text
/customer?id=fb5ddc93-1d5d-490d-ba5f-2c361cea41f7&type=sep31-sender
```

--------------------------------

### Create example directory

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/apps/ingest-sdk/ingestion-pipeline-code.mdx

Creates and enters the example directory for the pipeline sample.

```bash
mkdir pipeline-example; cd pipeline-example

```

--------------------------------

### GET /customer request by account and memo

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/sep-guide/sep31/integration.mdx

Example GET /customer request URL that identifies a customer using the Stellar account and memo, plus the customer type.

```text
/customer?account=GDJUOFZGW5WYBK4GIETCSSM6MTTIJ4SUMCQITPTLUWMQ6B4UIX2IEX47&memo=780284017&type=sep31-sender
```

--------------------------------

### Setup success output

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/stellar-disbursement-platform/admin-guide/getting-started.mdx

Expected output after the setup wizard completes. Provides the login URL and default tenant credentials for the SDP.

```text
🎉🎉🎉🎉 SUCCESS! 🎉🎉🎉🎉
Single tenant mode - Login URL:
🔗Default tenant: http://localhost:3000
  username: owner@default.local  password: Password123!
```

--------------------------------

### Get Prices (TypeScript, Dart, Swift)

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/apps/wallet/sep38.mdx

Call sep38.prices() with sell_asset and sell_amount to get indicative prices. The example requests prices for selling 5 fiat USD.

```typescript
const resp = await sep38.prices({
  sell_asset: "iso4217:USD",
  sell_amount: "5",
});
```

```dart
var resp = await sep38.prices(
  sellAsset: "iso4217:USD",
  sellAmount: "5",
);
```

```swift
let response = try await sep38.prices(sellAsset: "iso4217:USD",
                                      sellAmount: "5")
```

--------------------------------

### Initialize Go module for Token Transfer Processor example

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/indexers/build-your-own/processors/token-transfer-processor/examples/README.mdx

Run this command in the current directory to create a new Go module for the example exercise. Requires an existing Go module or creates a new one locally.

```bash
go mod init example/ttp_processor
```

--------------------------------

### Create accounts and fetch balances with @stellar/stellar-sdk

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/create-account.mdx

Complete JavaScript example using @stellar/stellar-sdk to create accounts via friendbot and the CreateAccount operation, then fetch native XLM and USDC trustline balances using the Soroban RPC server. Requires following the SDK installation and setup instructions from the Stellar documentation. The USDC balance will always be zero because no USDC is actually received.

```js
import {
  Keypair,
  BASE_FEE,
  Networks,
  Operation,
  Asset,
  humanizeEvents,
  TransactionBuilder,
} from "@stellar/stellar-sdk";
import { Server } from "@stellar/stellar-sdk/rpc";

// See https://developers.stellar.org/docs/data/apis/rpc/providers
const server = new Server("https://soroban-testnet.stellar.org");

const testnetUsdc = new Asset(
  "USDC",
  "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
);

async function main() {
  //
  // Generating keypairs
  //
  const parent = Keypair.random();
  console.log("Secret:", parent.secret());
  console.log("Public:", parent.publicKey());

  //
  // Account creation via friendbot (does not work on mainnet)
  //
  const friendbotResponse = await server.requestAirdrop(parent.publicKey());
  console.log("SUCCESS! You have a new account:\n", friendbotResponse);

  const parentAccount = await server.getAccount(parent.publicKey());
  const childAccount = Keypair.random();

  //
  // Account creation via the CreateAccount operation
  //
  const createAccountTx = new TransactionBuilder(parentAccount, {
    fee: BASE_FEE,
    networkPassphrase: Networks.TESTNET,
  })
    .addOperation(
      Operation.createAccount({
        destination: childAccount.publicKey(),
        startingBalance: "5",
      }),
    )
    .addOperation(Operation.changeTrust({ asset: testnetUsdc }))
    .setTimeout(180)
    .build();

  createAccountTx.sign(parent);

  const sendTxResponse = await server.sendTransaction(createAccountTx);
  if (sendTxResponse.status !== "PENDING") {
    console.log(`There was an error: ${JSON.stringify(sendTxResponse)}`);
    throw sendTxResponse;
  }

  const txResponse = await server.pollTransaction(sendTxResponse.hash);
  if (txResponse.status !== "SUCCESS") {
    console.log(
      `Transaction status: ${txResponse.status}, events: ${humanizeEvents(
        txResponse.diagnosticEvents,
      )}`,
    );
  }

  console.log("Created the new account", childAccount.publicKey());

  //
  // Fetching native and USDC balances
  //
  const accountEntry = await server.getAccountEntry(parent.publicKey());
  console.log("Balance for account: " + parent.publicKey());
  console.log("XLM:", accountEntry.balance().toString());

  const trustlineEntry = await server.getTrustline(
    parent.publicKey(),
    testnetUsdc,
  );
  console.log("USDC:", trustlineEntry.balance().toString());
}

main().catch((err) => console.error(err));
```

--------------------------------

### Install @stellar/mpp, mppx, and @stellar/stellar-sdk

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/agentic-payments/mpp/README.mdx

Install the MPP SDK, the core MPP framework library, and the Stellar SDK. Run this in your project directory before using the @stellar/mpp charge or session intents.

```bash
npm install @stellar/mpp mppx @stellar/stellar-sdk
```

--------------------------------

### Clone the soroban-examples repository

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/smart-contracts/example-contracts/bls-signature.mdx

Clone the main branch of the soroban-examples repository to get the BLS signature example.

```bash
git clone -b main https://github.com/stellar/soroban-examples
```

--------------------------------

### Install Horizon Helm chart with custom values.yaml

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/apis/horizon/admin-guide/running.mdx

Installs Horizon using a local values.yaml file instead of many --set flags. This is the recommended approach for customizing the deployment beyond the basic example.

```bash
helm install myhorizon stellar/horizon \
--namespace my-horizon-namespace-on-cluster \
--values values.yaml
```

--------------------------------

### Run the example tests with cargo

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/smart-contracts/example-contracts/TEMPLATE.mdx

Clone the soroban-examples repository, navigate into the hello_world directory, and run the tests with cargo test. The expected output shows the test passing.

```sh
git clone -b main https://github.com/stellar/soroban-examples
```

```sh
cd hello_world
cargo test
```

```sh
running 1 test
test test::test ... ok
```

--------------------------------

### Example of libFuzzer stack trace with symbols

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/smart-contracts/example-contracts/fuzzing.mdx

Shows a libFuzzer stack trace with demangled function names after installing llvm-symbolizer.

```text
==6323== ERROR: libFuzzer: deadly signal
    #0 0x557c9da6a431 in __sanitizer_print_stack_trace /rustc/llvm/src/llvm-project/compiler-rt/lib/asan/asan_stack.cpp:87:3
    #1 0x557ca0fb55b0 in fuzzer::PrintStackTrace() /home/azureuser/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.5/libfuzzer/FuzzerUtil.cpp:210:38
    #2 0x557ca0f8c08a in fuzzer::Fuzzer::CrashCallback() /home/azureuser/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.5/libfuzzer/FuzzerLoop.cpp:233:18
    #3 0x557ca0f8c08a in fuzzer::Fuzzer::CrashCallback() /home/azureuser/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.5/libfuzzer/FuzzerLoop.cpp:228:6
    #4 0x7ff19e84d08f  (/lib/x86_64-linux-gnu/libc.so.6+0x4308f) (BuildId: 1878e6b475720c7c51969e69ab2d276fae6d1dee)
    #5 0x7ff19e84d00a in __libc_signal_restore_set /build/glibc-SzIz7B/glibc-2.31/signal/../sysdeps/unix/sysv/linux/internal-signals.h:86:3
    #6 0x7ff19e84d00a in raise /build/glibc-SzIz7B/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:48:3
    #7 0x7ff19e82c858 in abort /build/glibc-SzIz7B/glibc-2.31/stdlib/abort.c:79:7
    ...
    #23 0x557c9daee89a in fuzz_target_1::assert_invariants::hd6d4f9549b31c01c /home/azureuser/data/stellar/soroban-examples/fuzzing/fuzz/fuzz_targets/fuzz_target_1.rs:103:5
    #24 0x557c9daee89a in fuzz_target_1::_::run::hac7cb1113ecbdf2b /home/azureuser/data/stellar/soroban-examples/fuzzing/fuzz/fuzz_targets/fuzz_target_1.rs:69:9
    #25 0x557c9daecea6 in rust_fuzzer_test_input /home/azureuser/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.5/src/lib.rs:297:60
    ...
    #37 0x557c9d9c8346 in main /home/azureuser/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.5/libfuzzer/FuzzerMain.cpp:20:30
    #38 0x7ff19e82e082 in __libc_start_main /build/glibc-SzIz7B/glibc-2.31/csu/../csu/libc-start.c:308:16
    #39 0x557c9d9c837d  (/home/azureuser/data/stellar/soroban-examples/fuzzing/fuzz/target/x86_64-unknown-linux-gnu/release/fuzz_target_1+0x1bde37d) (BuildId: 6a95a932984a405ebab8171dddc9f812fdf16846)
```

--------------------------------

### Quick Start: Clone, Run, and Verify Anchor Platform

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/admin-guide/getting-started.mdx

These commands clone the Anchor Platform repository, navigate to the quick-run directory, start all services, and verify the platform is responding by fetching the Stellar TOML file.

```bash
git clone https://github.com/stellar/anchor-platform
```

```bash
cd anchor-platform/quick-run
```

```bash
./ap_start.sh
```

```bash
curl http://localhost:8080/.well-known/stellar.toml
```

--------------------------------

### Get deployer account with ethers.js

Source: https://github.com/stellar/stellar-docs/blob/main/docs/learn/migrate/evm/smart-contract-deployment.mdx

Imports ethers from Hardhat and retrieves the deployer account. This is the starting point for a Hardhat deployment script.

```javascript
const { ethers } = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);
}
```

--------------------------------

### Create and initialize a Node.js project

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/guides/transactions/install-deploy-contract-with-code.mdx

Create a new directory for the Node.js project, navigate into it, initialize a new Node.js project, and install the Stellar SDK dependency.

```bash
mkdir deploy-contract
cd deploy-contract
```

```bash
npm init -y
npm install @stellar/stellar-sdk
```

--------------------------------

### Check Service Status with docker-compose ps

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/admin-guide/getting-started.mdx

Checks the status of all services started by the quick-run setup. All services should show as "Up" in the status column.

```bash
docker-compose ps
```

--------------------------------

### Run setup script via pnpm

Source: https://github.com/stellar/stellar-docs/blob/main/docs/build/apps/guestbook/bindings.mdx

Runs the initialize script using the package.json 'setup' script. Execute from the project root.

```shell
pnpm run setup
```

--------------------------------

### Create Account Operation Response

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/apis/horizon/api-reference/resources/operations/object/create-account.mdx

Example response for a successful create_account operation. Shows the operation details including the starting balance, funder, and new account address.

```json
{
  "_links": {
    "self": {
      "href": "https://horizon-testnet.stellar.org/operations/120192344791343105"
    },
    "transaction": {
      "href": "https://horizon-testnet.stellar.org/transactions/ef0fe04ac3c7de7228ca2598886059868ad05c224a041e8b2d9ee2a8a9dd6894"
    },
    "effects": {
      "href": "https://horizon-testnet.stellar.org/operations/120192344791343105/effects"
    },
    "succeeds": {
      "href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=120192344791343105"
    },
    "precedes": {
      "href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=120192344791343105"
    }
  },
  "id": "120192344791343105",
  "paging_token": "120192344791343105",
  "transaction_successful": true,
  "source_account": "GBVFTZL5HIPT4PFQVTZVIWR77V7LWYCXU4CLYWWHHOEXB64XPG5LDMTU",
  "type": "create_account",
  "type_i": 0,
  "created_at": "2020-01-29T19:43:59Z",
  "transaction_hash": "ef0fe04ac3c7de7228ca2598886059868ad05c224a041e8b2d9ee2a8a9dd6894",
  "starting_balance": "2.0000000",
  "funder": "GBVFTZL5HIPT4PFQVTZVIWR77V7LWYCXU4CLYWWHHOEXB64XPG5LDMTU",
  "account": "GAYOLLLUIZE4DZMBB2ZBKGBUBZLIOYU6XFLW37GBP2VZD3ABNXCW4BVA"
}
```

--------------------------------

### Run all API documentation steps

Source: https://github.com/stellar/stellar-docs/blob/main/openapi/horizon/README.md

This shortcut runs the clean, bundle, and generate steps all at once.

```bash
pnpm api
```

--------------------------------

### Horizon DB migration log lines

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/apis/horizon/admin-guide/upgrading.mdx

Example log lines indicating a database migration started and completed. Use to confirm that a DB migration was initiated during the upgrade.

```text
2023/09/22 18:27:01 Applying DB migrations...
2023/09/22 18:27:01 successfully applied 5 Horizon migrations
```

--------------------------------

### Initialize Node.js project and install dependencies

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/sep-guide/sep24/example.mdx

Commands to initialize a Node.js project, install Express and jsonwebtoken, and create the server.js file.

```bash
yarn init -y
yarn add express jsonwebtoken
touch server.js
```

--------------------------------

### Docker Compose setup for Anchor Platform and business server

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/anchor-platform/sep-guide/sep31/integration.mdx

Docker Compose configuration that starts the Anchor Platform's sep-server and platform-server, a custom business server, and a PostgreSQL database. The business server is expected to be built from the current directory and listens on port 8081. Run `docker compose up` to start all services.

```yaml
version: "3.8"

services:
  sep-server:
    image: stellar/anchor-platform:latest
    command: --sep-server
    env_file:
      - ./dev.env
    volumes:
      - ./config:/home
    ports:
      - "8080:8080"
    depends_on:
      - db
  platform-server:
    image: stellar/anchor-platform:latest
    command: --platform-server
    env_file:
      - ./dev.env
    volumes:
      - ./config:/home
    ports:
      - "8085:8085"
    depends_on:
      - db

  server:
    build: .
    ports:
      - "8081:8081"
    env_file:
      - ./dev.env
  db:
    image: postgres:14
    ports:
      - "5432:5432"
    env_file:
      - ./dev.env
```

--------------------------------

### stellar-disbursement-platform db setup-for-network [flags]

Source: https://github.com/stellar/stellar-docs/blob/main/docs/platforms/stellar-disbursement-platform/admin-guide/cli-manual.mdx

Shows the basic usage syntax for the `db setup-for-network` command, which sets up assets and wallets in the database based on the network passphrase.

```bash
stellar-disbursement-platform db setup-for-network [flags]
```

--------------------------------

### GET /ledgers

Source: https://github.com/stellar/stellar-docs/blob/main/docs/data/apis/horizon/api-reference/list-all-ledgers.api.mdx

This endpoint lists all ledgers and can be used in streaming mode. Streaming mode allows you to listen for new ledgers as they close. If called in streaming mode, Horizon will start at the earliest known ledger unless a cursor is set, in which case it will start from that cursor. By setting the cursor value to now, you can stream ledgers since your request time.

```APIDOC
## GET /ledgers

### Description
This endpoint lists all ledgers and can be used in streaming mode. Streaming mode allows you to listen for new ledgers as they close. If called in streaming mode, Horizon will start at the earliest known ledger unless a cursor is set, in which case it will start from that cursor. By setting the cursor value to now, you can stream ledgers since your request time.

### Method
GET

### Endpoint
/ledgers
```
Tokens:
Raw