stellar-agent-kit 1.0.0 → 1.0.3

package/README.md

@@ -0,0 +1,75 @@
+# stellar-agent-kit
+
+Unified TypeScript SDK for Stellar: payments, DEX (SoroSwap), lending (Blend), and oracles. AgentKit-style API: one class, `initialize()`, then protocol methods.
+
+## Install
+
+```bash
+npm install stellar-agent-kit
+```
+
+## Quick start
+
+```typescript
+import { StellarAgentKit, MAINNET_ASSETS } from "stellar-agent-kit";
+
+const agent = new StellarAgentKit(process.env.SECRET_KEY!, "mainnet");
+await agent.initialize();
+
+// Balances
+const balances = await agent.getBalances();
+
+// Send XLM
+await agent.sendPayment("G...", "10");
+
+// DEX quote + swap
+const quote = await agent.dexGetQuote(
+  { contractId: MAINNET_ASSETS.XLM.contractId },
+  { contractId: MAINNET_ASSETS.USDC.contractId },
+  "10000000" // 1 XLM (7 decimals)
+);
+await agent.dexSwap(quote);
+
+// Path payment (strict receive)
+await agent.pathPayment(
+  { assetCode: "XLM" },
+  "10",
+  "G...",
+  { assetCode: "USDC", issuer: "G..." },
+  "5",
+  []
+);
+
+// Create account
+await agent.createAccount("G...", "1");
+
+// Price (Reflector oracle)
+const price = await agent.getPrice({ symbol: "XLM" });
+```
+
+## API overview
+
+| Method | Description |
+|--------|-------------|
+| `initialize()` | Must be called once after construction. Sets up Horizon, DEX, oracle. |
+| `getBalances(accountId?)` | Native + trustline balances for an account (default: this key). |
+| `sendPayment(to, amount, assetCode?, assetIssuer?)` | Send a payment (XLM or custom asset). |
+| `createAccount(destination, startingBalance)` | Create a new account (funded from this key). |
+| `pathPayment(sendAsset, sendMax, destination, destAsset, destAmount, path?)` | Path payment strict receive. |
+| `dexGetQuote(from, to, amount)` | Get swap quote (SoroSwap aggregator). |
+| `dexSwap(quote)` | Execute a swap from a quote. |
+| `dexSwapExactIn(from, to, amount)` | Get quote and execute in one call. |
+| `getPrice(asset)` | Latest price from Reflector oracle. |
+| `lendingSupply(args)` | Supply to a Blend pool. |
+| `lendingBorrow(args)` | Borrow from a Blend pool. |
+
+## Network
+
+Currently **mainnet only**. Set `SECRET_KEY` and optionally `SOROSWAP_API_KEY` (for DEX quotes) in your environment.
+
+## Exports
+
+- `StellarAgentKit`, `StellarNetwork`
+- `getNetworkConfig`, `networks`, `MAINNET_ASSETS`, `SOROSWAP_AGGREGATOR`
+- `createDexClient`, `createReflectorOracle`, `lendingSupply`, `lendingBorrow`
+- Types: `DexAsset`, `QuoteResult`, `SwapResult`, `OracleAsset`, `PriceData`, `LendingSupplyArgs`, etc.

package/dist/index.cjs

@@ -20,18 +20,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALLBRIDGE_CORE_STELLAR_DOCS: () => ALLBRIDGE_CORE_STELLAR_DOCS,
+  BAND_ORACLE: () => BAND_ORACLE,
+  BLEND_POOLS: () => BLEND_POOLS,
+  BLEND_POOLS_MAINNET: () => BLEND_POOLS_MAINNET,
+  FXDAO_MAINNET: () => FXDAO_MAINNET,
   MAINNET_ASSETS: () => MAINNET_ASSETS,
+  REFLECTOR_ORACLE: () => REFLECTOR_ORACLE,
   SOROSWAP_AGGREGATOR: () => SOROSWAP_AGGREGATOR,
   StellarAgentKit: () => StellarAgentKit,
-  TESTNET_ASSETS: () => TESTNET_ASSETS,
   createDexClient: () => createDexClient,
+  createReflectorOracle: () => createReflectorOracle,
   getNetworkConfig: () => getNetworkConfig,
+  lendingBorrow: () => lendingBorrow,
+  lendingSupply: () => lendingSupply,
   networks: () => networks
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/agent.ts
-var import_stellar_sdk3 = require("@stellar/stellar-sdk");
+var import_stellar_sdk5 = require("@stellar/stellar-sdk");
 
 // src/config/networks.ts
 var import_zod = require("zod");
@@ -40,20 +48,16 @@ var NetworkConfigSchema = import_zod.z.object({
   sorobanRpcUrl: import_zod.z.string().url(),
   friendbotUrl: import_zod.z.string().url().optional()
 });
-var testnet = {
-  horizonUrl: "https://horizon-testnet.stellar.org",
-  sorobanRpcUrl: "https://soroban-testnet.stellar.org",
-  friendbotUrl: "https://friendbot.stellar.org"
-};
 var mainnet = {
   horizonUrl: "https://horizon.stellar.org",
   sorobanRpcUrl: "https://soroban-rpc.mainnet.stellar.gateway.fm"
 };
-var networks = { testnet, mainnet };
+var networks = { mainnet };
 function getNetworkConfig(name) {
-  const parsed = import_zod.z.enum(["testnet", "mainnet"]).safeParse(name);
-  if (!parsed.success) throw new Error(`Invalid network: ${name}. Use "testnet" or "mainnet".`);
-  return networks[parsed.data];
+  if (name && name !== "mainnet") {
+    throw new Error("This project is mainnet-only. Use network: 'mainnet'.");
+  }
+  return mainnet;
 }
 
 // src/dex/soroSwap.ts
@@ -76,10 +80,9 @@ function parseApiQuote(data) {
   };
 }
 function createSoroSwapDexClient(networkConfig, apiKey) {
-  const networkName = networkConfig.horizonUrl.includes("testnet") ? "testnet" : "mainnet";
   const key = apiKey ?? process.env.SOROSWAP_API_KEY;
   async function getQuote(from, to, amount) {
-    const url = `${SOROSWAP_API_BASE}/quote?network=${networkName}`;
+    const url = `${SOROSWAP_API_BASE}/quote?network=mainnet`;
     const body = {
       assetIn: assetToApiString(from),
       assetOut: assetToApiString(to),
@@ -100,7 +103,7 @@ function createSoroSwapDexClient(networkConfig, apiKey) {
     if (!key) throw new Error("executeSwap requires SOROSWAP_API_KEY");
     const keypair = import_stellar_sdk.Keypair.fromSecret(secretKey.trim());
     const fromAddress = keypair.publicKey();
-    const buildUrl = `${SOROSWAP_API_BASE}/quote/build?network=${networkName}`;
+    const buildUrl = `${SOROSWAP_API_BASE}/quote/build?network=mainnet`;
     const buildRes = await fetch(buildUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
@@ -110,8 +113,8 @@ function createSoroSwapDexClient(networkConfig, apiKey) {
     const buildData = await buildRes.json();
     const xdrBase64 = buildData?.xdr;
     if (!xdrBase64 || typeof xdrBase64 !== "string") throw new Error("SoroSwap build response missing xdr");
-    const config = getNetworkConfig(networkName);
-    const networkPassphrase = config.horizonUrl.includes("testnet") ? import_stellar_sdk.Networks.TESTNET : import_stellar_sdk.Networks.PUBLIC;
+    const config = getNetworkConfig("mainnet");
+    const networkPassphrase = import_stellar_sdk.Networks.PUBLIC;
     const tx = import_stellar_sdk.TransactionBuilder.fromXDR(xdrBase64, networkPassphrase);
     tx.sign(keypair);
     const server = new import_stellar_sdk2.rpc.Server(config.sorobanRpcUrl, { allowHttp: config.sorobanRpcUrl.startsWith("http:") });
@@ -127,6 +130,206 @@ function createDexClient(networkConfig, apiKey) {
   return createSoroSwapDexClient(networkConfig, apiKey);
 }
 
+// src/oracle/reflector.ts
+var import_stellar_sdk3 = require("@stellar/stellar-sdk");
+
+// src/config/oracles.ts
+var REFLECTOR_ORACLE = {
+  /** Stellar Mainnet DEX prices */
+  dex: "CALI2BYU2JE6WVRUFYTS6MSBNEHGJ35P4AVCZYF3B6QOE3QKOB2PLE6M",
+  /** External CEX & DEX rates */
+  cexDex: "CAFJZQWSED6YAWZU3GWRTOCNPPCGBN32L7QV43XX5LZLFTK6JLN34DLN",
+  /** Fiat exchange rates */
+  fiat: "CBKGPWGKSKZF52CFHMTRR23TBWTPMRDIYZ4O2P5VS65BMHYH4DXMCJZC"
+};
+var BAND_ORACLE = "CCQXWMZVM3KRTXTUPTN53YHL272QGKF32L7XEDNZ2S6OSUFK3NFBGG5M";
+
+// src/oracle/reflector.ts
+var SIMULATION_SOURCE_MAINNET = "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN";
+function assetToScVal(asset) {
+  if ("contractId" in asset && asset.contractId) {
+    const addr = new import_stellar_sdk3.Address(asset.contractId);
+    return import_stellar_sdk3.xdr.ScVal.scvVec([
+      import_stellar_sdk3.xdr.ScVal.scvSymbol("Stellar"),
+      import_stellar_sdk3.xdr.ScVal.scvAddress(addr.toScAddress())
+    ]);
+  }
+  if ("symbol" in asset && asset.symbol) {
+    return import_stellar_sdk3.xdr.ScVal.scvVec([
+      import_stellar_sdk3.xdr.ScVal.scvSymbol("Other"),
+      import_stellar_sdk3.xdr.ScVal.scvSymbol(asset.symbol)
+    ]);
+  }
+  throw new Error("Oracle asset must be { contractId } or { symbol }");
+}
+function parseLastPriceRetval(retvalInput, decimals) {
+  const retval = typeof retvalInput === "string" ? import_stellar_sdk3.xdr.ScVal.fromXDR(retvalInput, "base64") : retvalInput;
+  const vec = retval.vec();
+  if (!vec || vec.length === 0) {
+    throw new Error("Oracle returned no price (None) for this asset");
+  }
+  const inner = vec[0];
+  const dataVec = inner.vec();
+  if (dataVec && dataVec.length >= 2) {
+    const price = scValToI128(dataVec[0]);
+    const timestamp = Number(dataVec[1].u64()?.toString() ?? 0);
+    return { price, timestamp, decimals };
+  }
+  const m = inner.map();
+  if (m) {
+    for (const entry of m) {
+      const k = entry.key();
+      const v = entry.val();
+      if (k.sym && k.sym().toString() === "price" && v) {
+        const price = scValToI128(v);
+        let timestamp = 0;
+        for (const e2 of m) {
+          if (e2.key().sym && e2.key().sym().toString() === "timestamp") {
+            timestamp = Number(e2.val().u64()?.toString() ?? 0);
+            break;
+          }
+        }
+        return { price, timestamp, decimals };
+      }
+    }
+  }
+  throw new Error("Oracle price data format unexpected");
+}
+function scValToI128(val) {
+  const i128 = val.i128();
+  if (!i128) throw new Error("Expected i128 price");
+  const lo = i128.lo();
+  const hi = i128.hi();
+  if (!lo || hi === void 0) return "0";
+  const loNum = Number(lo);
+  const hiNum = Number(hi);
+  const negative = hiNum < 0;
+  const absLo = loNum < 0 ? 4294967296 + loNum : loNum;
+  const absHi = hiNum < 0 ? 4294967296 + hiNum : hiNum;
+  let n = BigInt(absLo) + (BigInt(absHi) << 32n);
+  if (negative) n = -n;
+  return String(n);
+}
+function createReflectorOracle(config) {
+  const feed = config.feed ?? "dex";
+  const contractId = REFLECTOR_ORACLE[feed];
+  const server = new import_stellar_sdk3.rpc.Server(config.networkConfig.sorobanRpcUrl, {
+    allowHttp: config.networkConfig.sorobanRpcUrl.startsWith("http:")
+  });
+  const networkPassphrase = import_stellar_sdk3.Networks.PUBLIC;
+  async function decimals() {
+    const contract = new import_stellar_sdk3.Contract(contractId);
+    const op = contract.call("decimals");
+    const acc = await server.getAccount(SIMULATION_SOURCE_MAINNET);
+    const tx = new import_stellar_sdk3.TransactionBuilder(acc, {
+      fee: "10000",
+      networkPassphrase
+    }).addOperation(op).setTimeout(30).build();
+    const sim = await server.simulateTransaction(tx);
+    if ("error" in sim && sim.error) throw new Error(String(sim.error));
+    const ret = sim?.result?.retval;
+    if (ret == null) throw new Error("No decimals retval");
+    const val = typeof ret === "string" ? import_stellar_sdk3.xdr.ScVal.fromXDR(ret, "base64") : ret;
+    const u = val.u32();
+    return u ?? 7;
+  }
+  async function lastprice(asset) {
+    const contract = new import_stellar_sdk3.Contract(contractId);
+    const assetScVal = assetToScVal(asset);
+    const op = contract.call("lastprice", assetScVal);
+    const acc = await server.getAccount(SIMULATION_SOURCE_MAINNET);
+    const tx = new import_stellar_sdk3.TransactionBuilder(acc, {
+      fee: "10000",
+      networkPassphrase
+    }).addOperation(op).setTimeout(30).build();
+    const sim = await server.simulateTransaction(tx);
+    if ("error" in sim && sim.error) throw new Error(String(sim.error));
+    const ret = sim?.result?.retval;
+    if (ret == null) throw new Error("Oracle lastprice: no retval");
+    const dec = await decimals();
+    return parseLastPriceRetval(ret, dec);
+  }
+  return { lastprice, decimals, contractId };
+}
+
+// src/lending/blend.ts
+var import_stellar_sdk4 = require("@stellar/stellar-sdk");
+var import_blend_sdk = require("@blend-capital/blend-sdk");
+var BLEND_POOLS_MAINNET = "CCCCIQSDILITHMM7PBSLVDT5MISSY7R26MNZXCX4H7J5JQ5FPIYOGYFS";
+var BLEND_POOLS = { mainnet: BLEND_POOLS_MAINNET };
+async function buildSubmitTx(networkConfig, secretKey, poolId, requests) {
+  const keypair = import_stellar_sdk4.Keypair.fromSecret(secretKey.trim());
+  const user = keypair.publicKey();
+  const pool = new import_blend_sdk.PoolContractV2(poolId);
+  const submitOpXdr = pool.submit({
+    from: user,
+    spender: user,
+    to: user,
+    requests
+  });
+  const op = import_stellar_sdk4.xdr.Operation.fromXDR(submitOpXdr, "base64");
+  const networkPassphrase = import_stellar_sdk4.Networks.PUBLIC;
+  const horizon = new import_stellar_sdk4.Horizon.Server(networkConfig.horizonUrl);
+  const sourceAccount = await horizon.loadAccount(user);
+  const tx = new import_stellar_sdk4.TransactionBuilder(sourceAccount, {
+    fee: "10000",
+    networkPassphrase
+  }).addOperation(op).setTimeout(180).build();
+  return { tx, keypair };
+}
+async function lendingSupply(networkConfig, secretKey, args) {
+  const amountBigInt = BigInt(args.amount);
+  const requests = [
+    {
+      request_type: import_blend_sdk.RequestType.SupplyCollateral,
+      address: args.assetContractId,
+      amount: amountBigInt
+    }
+  ];
+  const { tx, keypair } = await buildSubmitTx(
+    networkConfig,
+    secretKey,
+    args.poolId,
+    requests
+  );
+  const server = new import_stellar_sdk4.rpc.Server(networkConfig.sorobanRpcUrl, {
+    allowHttp: networkConfig.sorobanRpcUrl.startsWith("http:")
+  });
+  const prepared = await server.prepareTransaction(tx);
+  prepared.sign(keypair);
+  const sendResult = await server.sendTransaction(prepared);
+  if (sendResult.errorResult) {
+    throw new Error(`Blend supply failed: ${String(sendResult.errorResult)}`);
+  }
+  return { hash: sendResult.hash, status: sendResult.status ?? "PENDING" };
+}
+async function lendingBorrow(networkConfig, secretKey, args) {
+  const amountBigInt = BigInt(args.amount);
+  const requests = [
+    {
+      request_type: import_blend_sdk.RequestType.Borrow,
+      address: args.assetContractId,
+      amount: amountBigInt
+    }
+  ];
+  const { tx, keypair } = await buildSubmitTx(
+    networkConfig,
+    secretKey,
+    args.poolId,
+    requests
+  );
+  const server = new import_stellar_sdk4.rpc.Server(networkConfig.sorobanRpcUrl, {
+    allowHttp: networkConfig.sorobanRpcUrl.startsWith("http:")
+  });
+  const prepared = await server.prepareTransaction(tx);
+  prepared.sign(keypair);
+  const sendResult = await server.sendTransaction(prepared);
+  if (sendResult.errorResult) {
+    throw new Error(`Blend borrow failed: ${String(sendResult.errorResult)}`);
+  }
+  return { hash: sendResult.hash, status: sendResult.status ?? "PENDING" };
+}
+
 // src/agent.ts
 var StellarAgentKit = class {
   keypair;
@@ -135,18 +338,23 @@ var StellarAgentKit = class {
   _initialized = false;
   _dex = null;
   _horizon = null;
-  constructor(secretKey, network) {
-    this.keypair = import_stellar_sdk3.Keypair.fromSecret(secretKey.trim());
-    this.network = network;
-    this.config = getNetworkConfig(network);
+  _oracle = null;
+  constructor(secretKey, network = "mainnet") {
+    if (network !== "mainnet") {
+      throw new Error("This project is mainnet-only. Use network: 'mainnet'.");
+    }
+    this.keypair = import_stellar_sdk5.Keypair.fromSecret(secretKey.trim());
+    this.network = "mainnet";
+    this.config = getNetworkConfig();
   }
   /**
    * Initialize clients (Horizon, Soroban RPC, protocol wrappers).
    * Call after construction before using protocol methods.
    */
   async initialize() {
-    this._horizon = new import_stellar_sdk3.Horizon.Server(this.config.horizonUrl);
+    this._horizon = new import_stellar_sdk5.Horizon.Server(this.config.horizonUrl);
     this._dex = createDexClient(this.config, process.env.SOROSWAP_API_KEY);
+    this._oracle = createReflectorOracle({ networkConfig: this.config });
     this._initialized = true;
     return this;
   }
@@ -177,6 +385,43 @@ var StellarAgentKit = class {
     const quote = await this.dexGetQuote(fromAsset, toAsset, amount);
     return this.dexSwap(quote);
   }
+  // ─── Account & balances ────────────────────────────────────────────────────
+  /**
+   * Get balances for an account (native + trustlines).
+   * @param accountId - Stellar account ID (G...); defaults to this agent's public key
+   * @returns List of balances: asset code, issuer (if not native), balance string, and optional limit
+   */
+  async getBalances(accountId) {
+    this.ensureInitialized();
+    if (!this._horizon) throw new Error("Horizon not initialized");
+    const id = accountId ?? this.keypair.publicKey();
+    const account = await this._horizon.loadAccount(id);
+    return account.balances.map((b) => ({
+      assetCode: b.asset_code === "native" ? "XLM" : b.asset_code,
+      issuer: b.asset_issuer,
+      balance: b.balance,
+      limit: b.limit
+    }));
+  }
+  /**
+   * Create a new Stellar account (funding from this agent's account).
+   * @param destination - New account's public key (G...)
+   * @param startingBalance - Amount of XLM to send (e.g. "1" for 1 XLM; minimum ~1 XLM for base reserve)
+   * @returns Transaction hash
+   */
+  async createAccount(destination, startingBalance) {
+    this.ensureInitialized();
+    if (!this._horizon) throw new Error("Horizon not initialized");
+    const networkPassphrase = import_stellar_sdk5.Networks.PUBLIC;
+    const sourceAccount = await this._horizon.loadAccount(this.keypair.publicKey());
+    const tx = new import_stellar_sdk5.TransactionBuilder(sourceAccount, {
+      fee: "100",
+      networkPassphrase
+    }).addOperation(import_stellar_sdk5.Operation.createAccount({ destination, startingBalance })).setTimeout(180).build();
+    tx.sign(this.keypair);
+    const result = await this._horizon.submitTransaction(tx);
+    return { hash: result.hash };
+  }
   // ─── Payments (Horizon) ────────────────────────────────────────────────────
   /**
    * Send a native or custom-asset payment (Horizon).
@@ -188,47 +433,114 @@ var StellarAgentKit = class {
   async sendPayment(to, amount, assetCode, assetIssuer) {
     this.ensureInitialized();
     if (!this._horizon) throw new Error("Horizon not initialized");
-    const networkPassphrase = this.network === "testnet" ? import_stellar_sdk3.Networks.TESTNET : import_stellar_sdk3.Networks.PUBLIC;
+    const networkPassphrase = import_stellar_sdk5.Networks.PUBLIC;
+    const sourceAccount = await this._horizon.loadAccount(this.keypair.publicKey());
+    const asset = assetCode && assetIssuer ? new import_stellar_sdk5.Asset(assetCode, assetIssuer) : import_stellar_sdk5.Asset.native();
+    const tx = new import_stellar_sdk5.TransactionBuilder(sourceAccount, {
+      fee: "100",
+      networkPassphrase
+    }).addOperation(import_stellar_sdk5.Operation.payment({ destination: to, asset, amount })).setTimeout(180).build();
+    tx.sign(this.keypair);
+    const result = await this._horizon.submitTransaction(tx);
+    return { hash: result.hash };
+  }
+  /**
+   * Path payment (strict receive): send up to sendMax of sendAsset so destination receives exactly destAmount of destAsset.
+   * @param sendAsset - Asset to send (native or { code, issuer })
+   * @param sendMax - Maximum amount of sendAsset to send (display units)
+   * @param destination - Recipient account (G...)
+   * @param destAsset - Asset the recipient receives
+   * @param destAmount - Exact amount of destAsset the recipient gets (display units)
+   * @param path - Optional intermediate assets for the path
+   */
+  async pathPayment(sendAsset, sendMax, destination, destAsset, destAmount, path = []) {
+    this.ensureInitialized();
+    if (!this._horizon) throw new Error("Horizon not initialized");
+    const send = sendAsset.assetCode === "XLM" && !sendAsset.issuer ? import_stellar_sdk5.Asset.native() : new import_stellar_sdk5.Asset(sendAsset.assetCode, sendAsset.issuer);
+    const dest = destAsset.assetCode === "XLM" && !destAsset.issuer ? import_stellar_sdk5.Asset.native() : new import_stellar_sdk5.Asset(destAsset.assetCode, destAsset.issuer);
+    const pathAssets = path.map(
+      (p) => p.assetCode === "XLM" && !p.issuer ? import_stellar_sdk5.Asset.native() : new import_stellar_sdk5.Asset(p.assetCode, p.issuer)
+    );
+    const networkPassphrase = import_stellar_sdk5.Networks.PUBLIC;
     const sourceAccount = await this._horizon.loadAccount(this.keypair.publicKey());
-    const asset = assetCode && assetIssuer ? new import_stellar_sdk3.Asset(assetCode, assetIssuer) : import_stellar_sdk3.Asset.native();
-    const tx = new import_stellar_sdk3.TransactionBuilder(sourceAccount, {
+    const tx = new import_stellar_sdk5.TransactionBuilder(sourceAccount, {
       fee: "100",
       networkPassphrase
-    }).addOperation(import_stellar_sdk3.Operation.payment({ destination: to, asset, amount })).setTimeout(180).build();
+    }).addOperation(
+      import_stellar_sdk5.Operation.pathPaymentStrictReceive({
+        sendAsset: send,
+        sendMax,
+        destination,
+        destAsset: dest,
+        destAmount,
+        path: pathAssets
+      })
+    ).setTimeout(180).build();
     tx.sign(this.keypair);
     const result = await this._horizon.submitTransaction(tx);
     return { hash: result.hash };
   }
-  // ─── Placeholders for lending / oracle / cross-chain (plug later) ────────────
-  // async lendingSupply(asset: DexAsset, amount: string): Promise<{ hash: string }> { ... }
-  // async lendingBorrow(asset: DexAsset, amount: string): Promise<{ hash: string }> { ... }
-  // async getPrice(assetOrFeedId: string): Promise<{ price: string }> { ... }
-  // async crossChainSwap(...): Promise<SwapResult> { ... }
+  // ─── Oracle (Reflector SEP-40) ─────────────────────────────────────────────
+  /**
+   * Get latest price for an asset from Reflector oracle.
+   * @param asset - { contractId: "C..." } for on-chain token or { symbol: "XLM" } for ticker
+   */
+  async getPrice(asset) {
+    this.ensureInitialized();
+    if (!this._oracle) throw new Error("Oracle not initialized");
+    return this._oracle.lastprice(asset);
+  }
+  // ─── Lending (Blend) ───────────────────────────────────────────────────────
+  /**
+   * Supply (deposit) an asset to a Blend pool.
+   */
+  async lendingSupply(args) {
+    this.ensureInitialized();
+    return lendingSupply(this.config, this.keypair.secret(), args);
+  }
+  /**
+   * Borrow an asset from a Blend pool.
+   */
+  async lendingBorrow(args) {
+    this.ensureInitialized();
+    return lendingBorrow(this.config, this.keypair.secret(), args);
+  }
 };
 
 // src/config/assets.ts
-var TESTNET_ASSETS = {
-  XLM: { contractId: "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC" },
-  USDC: { contractId: "CBBHRKEP5M3NUDRISGLJKGHDHX3DA2CN2AZBQY6WLVUJ7VNLGSKBDUCM" },
-  /** Classic testnet USDC */
-  AUSDC: { code: "AUSDC", issuer: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN" }
-};
 var MAINNET_ASSETS = {
   XLM: { contractId: "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA" },
   USDC: { contractId: "CCW67TSZV3SSS2HXMBQ5JFGCKJNXKZM7UQUWUZPUTHXSTZLEO7SJMI75" }
 };
-var SOROSWAP_AGGREGATOR = {
-  testnet: "CCJUD55AG6W5HAI5LRVNKAE5WDP5XGZBUDS5WNTIVDU7O264UZZE7BRD",
-  mainnet: "CAG5LRYQ5JVEUI5TEID72EYOVX44TTUJT5BQR2J6J77FH65PCCFAJDDH"
+var SOROSWAP_AGGREGATOR = "CAG5LRYQ5JVEUI5TEID72EYOVX44TTUJT5BQR2J6J77FH65PCCFAJDDH";
+
+// src/config/protocols.ts
+var FXDAO_MAINNET = {
+  vaults: "CCUN4RXU5VNDHSF4S4RKV4ZJYMX2YWKOH6L4AKEKVNVDQ7HY5QIAO4UB",
+  lockingPool: "CDCART6WRSM2K4CKOAOB5YKUVBSJ6KLOVS7ZEJHA4OAQ2FXX7JOHLXIP",
+  usdx: "CDIKURWHYS4FFTR5KOQK6MBFZA2K3E26WGBQI6PXBYWZ4XIOPJHDFJKP",
+  eurx: "CBN3NCJSMOQTC6SPEYK3A44NU4VS3IPKTARJLI3Y77OH27EWBY36TP7U",
+  gbpx: "CBCO65UOWXY2GR66GOCMCN6IU3Y45TXCPBY3FLUNL4AOUMOCKVIVV6JC",
+  fxg: "CDBR4FMYL5WPUDBIXTBEBU2AFEYTDLXVOTRZHXS3JC575C7ZQRKYZQ55",
+  oracle: "CB5OTV4GV24T5USEZHFVYGC3F4A4MPUQ3LN56E76UK2IT7MJ6QXW4TFS"
 };
+var ALLBRIDGE_CORE_STELLAR_DOCS = "https://docs-core.allbridge.io/sdk/guides/stellar";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALLBRIDGE_CORE_STELLAR_DOCS,
+  BAND_ORACLE,
+  BLEND_POOLS,
+  BLEND_POOLS_MAINNET,
+  FXDAO_MAINNET,
   MAINNET_ASSETS,
+  REFLECTOR_ORACLE,
   SOROSWAP_AGGREGATOR,
   StellarAgentKit,
-  TESTNET_ASSETS,
   createDexClient,
+  createReflectorOracle,
   getNetworkConfig,
+  lendingBorrow,
+  lendingSupply,
   networks
 });
 //# sourceMappingURL=index.cjs.map