Stellar RPC Node - Public Beta

# RPC Passthrough - No fee sponsorship, standard JSON-RPC calls
# pip install stellar-sdk requests

import requests, json
from stellar_sdk import Keypair

SERVER = "https://mainnet.stellar.apicharge.com"
SECRET_KEY = "YOUR_SECRET_KEY"  # Replace with your key

keypair = Keypair.from_secret(SECRET_KEY)

# 1. Get quote for RPC access
quotes = requests.get(f"{SERVER}/apicharge/quote").json()
rpc_quote = next(q for q in quotes["quotes"]
                   if "stellar-rpc-developer" in q["signableEntity"]["routeId"])

# 2. Purchase access token (see full example for details)
token = purchase_access_token(SERVER, rpc_quote, keypair)

# 3. Make RPC calls via passthrough route
rpc_request = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getHealth"
}

response = requests.post(
    f"{SERVER}/soroban/developer/",
    headers={"apicharge": token, "Content-Type": "application/json"},
    json=rpc_request
)
print(response.json())  # {"jsonrpc": "2.0", "result": {"status": "healthy"}, ...}

// RPC Passthrough - No fee sponsorship, standard JSON-RPC calls
// npm install @stellar/stellar-sdk

const { Keypair } = require('@stellar/stellar-sdk');

const SERVER = 'https://mainnet.stellar.apicharge.com';
const SECRET_KEY = 'YOUR_SECRET_KEY';  // Replace with your key

const keypair = Keypair.fromSecret(SECRET_KEY);

// 1. Get quote for RPC access
const quotes = await fetch(`${SERVER}/apicharge/quote`).then(r => r.json());
const rpcQuote = quotes.quotes.find(q =>
    q.signableEntity.routeId.includes('stellar-rpc-developer'));

// 2. Purchase access token (see full example for details)
const token = await purchaseAccessToken(SERVER, rpcQuote, keypair);

// 3. Make RPC calls via passthrough route
const response = await fetch(`${SERVER}/soroban/developer/`, {
    method: 'POST',
    headers: {
        'apicharge': token,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'getHealth'
    })
});
console.log(await response.json()); // {jsonrpc: "2.0", result: {status: "healthy"}}

# Basic Account Activation - Creates account with XLM only
# pip install stellar-sdk requests

import requests
from stellar_sdk import Keypair

SERVER = "https://mainnet.stellar.apicharge.com"
SECRET_KEY = "YOUR_SECRET_KEY"  # Payer's secret key

payer = Keypair.from_secret(SECRET_KEY)

# Generate new account to activate
new_account = Keypair.random()
print(f"New account: {new_account.public_key}")

# 1. Get quote and purchase token
quotes = requests.get(f"{SERVER}/apicharge/quote").json()
activate_quote = next(q for q in quotes["quotes"]
                       if "stablecoin-activate-account" in q["signableEntity"]["routeId"])
token = purchase_access_token(SERVER, activate_quote, payer)

# 2. Call activate-account (Phase 1)
response = requests.post(
    f"{SERVER}/apicharge/stablecoin/activate-account",
    headers={"apicharge": token},
    json={"publicKey": new_account.public_key}
)
result = response.json()

print(f"Status: {result['status']}")
print(f"TX Hash: {result['transactionHash']}")
# Account now exists with XLM base reserve!
# Trustlines NOT established - use Full Activation for that

// Basic Account Activation - Creates account with XLM only
// npm install @stellar/stellar-sdk

const { Keypair } = require('@stellar/stellar-sdk');

const SERVER = 'https://mainnet.stellar.apicharge.com';
const SECRET_KEY = 'YOUR_SECRET_KEY';  // Payer's secret key

const payer = Keypair.fromSecret(SECRET_KEY);

// Generate new account to activate
const newAccount = Keypair.random();
console.log(`New account: ${newAccount.publicKey()}`);

// 1. Get quote and purchase token
const quotes = await fetch(`${SERVER}/apicharge/quote`).then(r => r.json());
const activateQuote = quotes.quotes.find(q =>
    q.signableEntity.routeId.includes('stablecoin-activate-account'));
const token = await purchaseAccessToken(SERVER, activateQuote, payer);

// 2. Call activate-account (Phase 1)
const response = await fetch(`${SERVER}/apicharge/stablecoin/activate-account`, {
    method: 'POST',
    headers: { 'apicharge': token, 'Content-Type': 'application/json' },
    body: JSON.stringify({ publicKey: newAccount.publicKey() })
});
const result = await response.json();

console.log(`Status: ${result.status}`);
console.log(`TX Hash: ${result.transactionHash}`);
// Account now exists with XLM base reserve!

# Full Account Activation - Creates account + USDC/EURC trustlines
import requests
from stellar_sdk import Keypair, TransactionBuilder, Network

SERVER = "https://mainnet.stellar.apicharge.com"
SECRET_KEY = "YOUR_SECRET_KEY"

payer = Keypair.from_secret(SECRET_KEY)
new_account = Keypair.random()

# Phase 1: Create account
token = purchase_access_token(SERVER, activate_quote, payer)
phase1 = requests.post(
    f"{SERVER}/apicharge/stablecoin/activate-account",
    headers={"apicharge": token},
    json={"publicKey": new_account.public_key}
).json()

# Phase 2: Sign trustline transaction and submit
if phase1.get("ticket") and phase1.get("trustlineTransactionXdr"):
    # Decode transaction, sign with NEW account's key
    tx = TransactionBuilder.from_xdr(
        phase1["trustlineTransactionXdr"],
        network_passphrase=Network.PUBLIC_NETWORK_PASSPHRASE
    )
    tx.sign(new_account)

    # Submit Phase 2
    phase2 = requests.post(
        f"{SERVER}/apicharge/stablecoin/activate-account",
        headers={"apicharge": token},
        json={
            "publicKey": new_account.public_key,
            "ticket": phase1["ticket"],
            "callerAccount": new_account.public_key,
            "signedEnvelopeXdr": tx.to_xdr()
        }
    )
    print("Trustlines established!" if phase2.ok else phase2.text)

// Full Account Activation - Creates account + USDC/EURC trustlines
const { Keypair, TransactionBuilder, Networks } = require('@stellar/stellar-sdk');

const SERVER = 'https://mainnet.stellar.apicharge.com';
const SECRET_KEY = 'YOUR_SECRET_KEY';

const payer = Keypair.fromSecret(SECRET_KEY);
const newAccount = Keypair.random();

// Phase 1: Create account
const token = await purchaseAccessToken(SERVER, activateQuote, payer);
const phase1 = await fetch(`${SERVER}/apicharge/stablecoin/activate-account`, {
    method: 'POST',
    headers: { 'apicharge': token, 'Content-Type': 'application/json' },
    body: JSON.stringify({ publicKey: newAccount.publicKey() })
}).then(r => r.json());

// Phase 2: Sign trustline transaction and submit
if (phase1.ticket && phase1.trustlineTransactionXdr) {
    // Decode and sign with NEW account's key
    const tx = TransactionBuilder.fromXDR(
        phase1.trustlineTransactionXdr,
        Networks.PUBLIC
    );
    tx.sign(newAccount);

    // Submit Phase 2
    const phase2 = await fetch(`${SERVER}/apicharge/stablecoin/activate-account`, {
        method: 'POST',
        headers: { 'apicharge': token, 'Content-Type': 'application/json' },
        body: JSON.stringify({
            publicKey: newAccount.publicKey(),
            ticket: phase1.ticket,
            callerAccount: newAccount.publicKey(),
            signedEnvelopeXdr: tx.toXDR()
        })
    });
    console.log(phase2.ok ? 'Trustlines established!' : await phase2.text());
}

# Fee-Sponsored USDC Payment - Zero network fees for sender
import requests
from stellar_sdk import Keypair, Network, TransactionBuilder, Asset

SERVER = "https://mainnet.stellar.apicharge.com"
USDC = Asset("USDC", "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN")

SECRET_KEY = "YOUR_SECRET_KEY"
RECIPIENT = "GXXXX..."  # Recipient public key
AMOUNT = "1.00"

keypair = Keypair.from_secret(SECRET_KEY)

# 1. Get quote and purchase token
quotes = requests.get(f"{SERVER}/apicharge/quote").json()
submit_quote = next(q for q in quotes["quotes"]
                     if "stablecoin-submit-classic-tx" in q["signableEntity"]["routeId"])
token = purchase_access_token(SERVER, submit_quote, keypair)

# 2. Build ZERO-FEE transaction
sequence = get_account_sequence(keypair.public_key)
tx = TransactionBuilder(
    source_account=Account(keypair.public_key, sequence),
    network_passphrase=Network.PUBLIC_NETWORK_PASSPHRASE,
    base_fee=0  # ZERO FEE!
).append_payment_op(RECIPIENT, USDC, AMOUNT).set_timeout(300).build()
tx.sign(keypair)

# 3. Submit - ApiCharge sponsors the network fee!
result = requests.post(
    f"{SERVER}/apicharge/stablecoin/submit-transaction",
    headers={"apicharge": token},
    json={"transactionXdr": tx.to_xdr()}
).json()
print(f"TX Hash: {result['transactionHash']}")

// Fee-Sponsored USDC Payment - Zero network fees for sender
const { Keypair, Networks, TransactionBuilder, Asset, Account } =
    require('@stellar/stellar-sdk');

const SERVER = 'https://mainnet.stellar.apicharge.com';
const USDC = new Asset('USDC', 'GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN');

const SECRET_KEY = 'YOUR_SECRET_KEY';
const RECIPIENT = 'GXXXX...';
const AMOUNT = '1.00';

const keypair = Keypair.fromSecret(SECRET_KEY);

// 1. Get quote and purchase token
const quotes = await fetch(`${SERVER}/apicharge/quote`).then(r => r.json());
const submitQuote = quotes.quotes.find(q =>
    q.signableEntity.routeId.includes('stablecoin-submit-classic-tx'));
const token = await purchaseAccessToken(SERVER, submitQuote, keypair);

// 2. Build ZERO-FEE transaction
const sequence = await getAccountSequence(keypair.publicKey());
const account = new Account(keypair.publicKey(), sequence);

const tx = new TransactionBuilder(account, {
    fee: '0',  // ZERO FEE!
    networkPassphrase: Networks.PUBLIC
})
.addOperation(Operation.payment({ destination: RECIPIENT, asset: USDC, amount: AMOUNT }))
.setTimeout(300).build();
tx.sign(keypair);

// 3. Submit - ApiCharge sponsors the network fee!
const result = await fetch(`${SERVER}/apicharge/stablecoin/submit-transaction`, {
    method: 'POST',
    headers: { 'apicharge': token, 'Content-Type': 'application/json' },
    body: JSON.stringify({ transactionXdr: tx.toXDR() })
}).then(r => r.json());
console.log(`TX Hash: ${result.transactionHash}`);