Submit transactions

// npm install @stellar/stellar-sdk && node pay.mjs
import {
  Asset, BASE_FEE, Contract, Keypair, Networks, TransactionBuilder, nativeToScVal, rpc,
} from "@stellar/stellar-sdk";

const server = new rpc.Server("https://rpc-testnet.lumeus.dev", {
  headers: { Authorization: `Bearer ${process.env.LUMEUS_API_KEY}` },
});

// 1. Create two Testnet accounts and fund them with Friendbot.
const sender = Keypair.random();
const recipient = Keypair.random();
for (const kp of [sender, recipient]) {
  const res = await fetch(`https://friendbot.stellar.org/?addr=${kp.publicKey()}`);
  if (!res.ok) throw new Error(`Friendbot ${res.status}`);
}
console.log("sender", sender.publicKey());

// 2. Build a 10 XLM payment through the native asset contract.
const xlm = new Contract(Asset.native().contractId(Networks.TESTNET));
const account = await server.getAccount(sender.publicKey());
const tx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: Networks.TESTNET })
  .addOperation(xlm.call("transfer",
    nativeToScVal(sender.publicKey(), { type: "address" }),
    nativeToScVal(recipient.publicKey(), { type: "address" }),
    nativeToScVal(100_000_000n, { type: "i128" }))) // 10 XLM in stroops
  .setTimeout(60)
  .build();

// 3. Simulate and add resources, fees and auth (simulateTransaction).
const prepared = await server.prepareTransaction(tx);

// 4. Sign locally. Only the signed envelope leaves your machine.
prepared.sign(sender);

// 5. Submit.
const sent = await server.sendTransaction(prepared);
console.log("send", sent.status, sent.hash);
if (sent.status !== "PENDING" && sent.status !== "DUPLICATE") {
  throw new Error(`sendTransaction ${sent.status}`);
}

// 6. Poll getTransaction until it leaves NOT_FOUND.
let result;
for (let i = 0; i < 30; i++) {
  result = await server.getTransaction(sent.hash);
  if (result.status !== "NOT_FOUND") break;
  await new Promise((r) => setTimeout(r, 2000));
}
if (result.status === "NOT_FOUND") throw new Error(`still NOT_FOUND after 60 s: poll ${sent.hash} again`);
console.log("result", result.status, "ledger", result.ledger);

# pip install stellar-sdk && python pay.py
import os
import time

import requests
from stellar_sdk import Asset, Keypair, Network, SorobanServer, TransactionBuilder, scval
from stellar_sdk.client.requests_client import RequestsClient

key = os.environ["LUMEUS_API_KEY"]
# num_retries=0: raise 429/503 at once instead of sleeping through Retry-After.
server = SorobanServer(
    "https://rpc-testnet.lumeus.dev",
    client=RequestsClient(num_retries=0, custom_headers={"Authorization": f"Bearer {key}"}),
)

# 1. Create two Testnet accounts and fund them with Friendbot.
sender, recipient = Keypair.random(), Keypair.random()
for kp in (sender, recipient):
    requests.get("https://friendbot.stellar.org/", params={"addr": kp.public_key}, timeout=30).raise_for_status()
print("sender", sender.public_key)

# 2. Build a 10 XLM payment through the native asset contract.
xlm = Asset.native().contract_id(Network.TESTNET_NETWORK_PASSPHRASE)
account = server.load_account(sender.public_key)
tx = (
    TransactionBuilder(account, Network.TESTNET_NETWORK_PASSPHRASE, base_fee=100)
    .append_invoke_contract_function_op(
        contract_id=xlm,
        function_name="transfer",
        parameters=[
            scval.to_address(sender.public_key),
            scval.to_address(recipient.public_key),
            scval.to_int128(100_000_000),  # 10 XLM in stroops
        ],
    )
    .set_timeout(60)
    .build()
)

# 3. Simulate and add resources, fees and auth (simulateTransaction).
tx = server.prepare_transaction(tx)

# 4. Sign locally. Only the signed envelope leaves your machine.
tx.sign(sender)

# 5. Submit.
sent = server.send_transaction(tx)
print("send", sent.status.value, sent.hash)
if sent.status.value not in ("PENDING", "DUPLICATE"):
    raise SystemExit(f"sendTransaction {sent.status.value}: {sent.error_result_xdr}")

# 6. Poll getTransaction until it leaves NOT_FOUND.
for _ in range(30):
    result = server.get_transaction(sent.hash)
    if result.status.value != "NOT_FOUND":
        break
    time.sleep(2)
if result.status.value == "NOT_FOUND":
    raise SystemExit(f"still NOT_FOUND after 60 s: poll {sent.hash} again")
print("result", result.status.value, "ledger", result.ledger)