@xoxno/sdk-js 1.0.119 → 1.0.120

package/dist/sdk/stellar/__tests__/swap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/stellar/contracts.d.ts

@@ -17,7 +17,8 @@ export type StellarNetwork = 'mainnet' | 'testnet';
 export declare const STELLAR_LENDING_CONTROLLER: Record<StellarNetwork, string>;
 /**
  * Stellar aggregator router contract addresses per network.
- * Targets `batch_execute(BatchSwap)` for direct (non-lending) swaps.
+ * Targets `execute_strategy(sender, total_in, swap_xdr)` for direct
+ * (non-lending) swaps.
  * Env vars:
  *   - STELLAR_AGGREGATOR_ROUTER_MAINNET
  *   - STELLAR_AGGREGATOR_ROUTER_TESTNET
@@ -50,6 +51,6 @@ export declare const STELLAR_NETWORK_PASSPHRASE: Record<StellarNetwork, string>;
 export declare function getStellarLendingController(network: StellarNetwork): string;
 /**
  * Assert an aggregator router address is configured for the target network.
- * Used by `buildStellarBatchSwapTx` for direct user→router swaps.
+ * Used by `buildStellarExecuteStrategyTx` for direct user -> router swaps.
  */
 export declare function getStellarAggregatorRouter(network: StellarNetwork): string;

package/dist/sdk/stellar/lending.d.ts

@@ -15,9 +15,10 @@
  * `rpc.Server.prepareTransaction` (simulation + Soroban footprint/auth/resource
  * fee) before handing the XDR to the wallet to sign.
  */
-import type { AggregatorSwapDto, BorrowArgs, FlashLoanArgs, LiquidateArgs, MultiplyArgs, RepayArgs, RepayDebtWithCollateralArgs, SupplyArgs, SwapCollateralArgs, SwapDebtArgs, SwapHopDto, SwapPathDto, SwapVenue, WithdrawArgs } from '@xoxno/types';
+import type { BorrowArgs, FlashLoanArgs, LiquidateArgs, MultiplyArgs, RepayArgs, RepayDebtWithCollateralArgs, SupplyArgs, SwapCollateralArgs, SwapDebtArgs, WithdrawArgs } from '@xoxno/types';
 import { xdr } from '@stellar/stellar-sdk';
 import { type StellarNetwork } from './contracts';
+import { type StellarStrategySwapHopInput, type StellarStrategySwapInput, type StellarStrategySwapPathInput } from './scval-encode';
 /**
  * Stellar `G...` public key of the caller (tx source account).
  */
@@ -52,14 +53,16 @@ export interface BuiltStellarTx {
  * `MultiplyArgs.steps`, `SwapDebtArgs.steps`, `SwapCollateralArgs.steps`, and
  * `RepayDebtWithCollateralArgs.steps`.
  *
- * `@xoxno/types` declares `steps: unknown` on these DTOs so every chain owns its
- * own encoding. On Stellar, callers must pass an `AggregatorSwapDto`, which is
- * serialised into the Soroban `AggregatorSwap` struct.
+ * `@xoxno/types` declares `steps: unknown` on these DTOs so every chain owns
+ * its own encoding. On Stellar, callers pass opaque aggregator strategy bytes,
+ * normally the quote response `routeXdr` (base64 ScVal XDR) or `{ routeXdr }`.
+ * The lending controller forwards those bytes to the aggregator and does not
+ * decode the aggregator route.
  */
-export type StellarSwapStepsInput = AggregatorSwapDto;
-export type StellarSwapHopInput = SwapHopDto;
-export type StellarSwapPathInput = SwapPathDto;
-export type StellarSwapVenue = SwapVenue;
+export type StellarSwapStepsInput = StellarStrategySwapInput;
+export type StellarSwapHopInput = StellarStrategySwapHopInput;
+export type StellarSwapPathInput = StellarStrategySwapPathInput;
+export type { StellarSwapVenue } from './scval-encode';
 /**
  * Assemble an unsigned XDR that invokes a single Soroban contract method.
  *
@@ -98,8 +101,8 @@ export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, arg
 /**
  * multiply(caller, account_id, e_mode_category, collateral_token,
  *          debt_to_flash_loan: i128, debt_token, mode: PositionMode,
- *          swap: AggregatorSwap, initial_payment: Option<(Address, i128)>,
- *          convert_swap: Option<AggregatorSwap>) -> u64
+ *          swap: Bytes, initial_payment: Option<(Address, i128)>,
+ *          convert_swap: Option<Bytes>) -> u64
  *
  * `mode` is a repr(u32) `PositionMode` → encoded as `scvU32`. The two trailing
  * `Option`s seed an optional initial collateral payment and a secondary swap
@@ -108,17 +111,17 @@ export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, arg
 export declare function buildStellarMultiplyTx(opts: StellarBuilderOptions, args: MultiplyArgs): BuiltStellarTx;
 /**
  * swap_debt(caller, account_id, existing_debt_token, new_debt_amount: i128,
- *           new_debt_token, steps: SwapSteps)
+ *           new_debt_token, steps: Bytes)
  */
 export declare function buildStellarSwapDebtTx(opts: StellarBuilderOptions, args: SwapDebtArgs): BuiltStellarTx;
 /**
  * swap_collateral(caller, account_id, current_collateral, from_amount: i128,
- *                 new_collateral, steps: SwapSteps)
+ *                 new_collateral, steps: Bytes)
  */
 export declare function buildStellarSwapCollateralTx(opts: StellarBuilderOptions, args: SwapCollateralArgs): BuiltStellarTx;
 /**
  * repay_debt_with_collateral(caller, account_id, collateral_token,
  *                            collateral_amount: i128, debt_token,
- *                            steps: SwapSteps, close_position: bool)
+ *                            steps: Bytes, close_position: bool)
  */
 export declare function buildStellarRepayDebtWithCollateralTx(opts: StellarBuilderOptions, args: RepayDebtWithCollateralArgs): BuiltStellarTx;

package/dist/sdk/stellar/scval-encode.d.ts

@@ -5,14 +5,39 @@
  * Addresses (Stellar `G...` accounts and Soroban `C...` contracts) encode via
  * `new Address(str).toScVal()`.
  */
-import type { AggregatorSwapDto, SwapVenue } from '@xoxno/types';
 import { xdr } from '@stellar/stellar-sdk';
 /**
  * On-chain swap venues, validated at runtime for a caller-supplied venue.
- * Mirrors `SWAP_VENUES` from `@xoxno/types` and the contract's `SwapVenue` enum.
+ * Mirrors the Soroban-only aggregator router's `SwapVenue` enum.
  */
-export declare const STELLAR_SWAP_VENUES: readonly ["Soroswap", "Aquarius", "Phoenix", "NativeAmm", "StaticBridge"];
-export type StellarSwapStepsInput = AggregatorSwapDto;
+export declare const STELLAR_SWAP_VENUES: readonly ["Soroswap", "Aquarius", "Phoenix", "Sushi", "CometDex"];
+export type StellarSwapVenue = (typeof STELLAR_SWAP_VENUES)[number];
+export interface StellarStrategySwapHopInput {
+    amountOut: string;
+    pool: string;
+    tokenIn: string;
+    tokenOut: string;
+    venue: StellarSwapVenue;
+}
+export interface StellarStrategySwapPathInput {
+    hops: StellarStrategySwapHopInput[];
+    splitPpm: number;
+}
+export interface StellarStrategyPayloadInput {
+    paths: StellarStrategySwapPathInput[];
+    referralId?: number | string;
+    tokenIn: string;
+    tokenOut: string;
+    totalMinOut: string;
+}
+export type StellarStrategySwapInput = string | Uint8Array | {
+    routeXdr: string;
+} | {
+    swapXdr: string;
+} | {
+    bytes: string | Uint8Array;
+} | StellarStrategyPayloadInput;
+export type StellarSwapStepsInput = StellarStrategySwapInput;
 export declare const addr: (a: string) => xdr.ScVal;
 export declare const i128: (s: string) => xdr.ScVal;
 export declare const u32: (n: number) => xdr.ScVal;
@@ -57,21 +82,32 @@ export declare const scStruct: (fields: Record<string, xdr.ScVal>) => xdr.ScVal;
  * Encode a Soroban `enum SwapVenue` (tag-only / unit variant). At the XDR level
  * a unit variant is `scvVec([symbol_name])`.
  */
-export declare const encodeSwapVenue: (venue: SwapVenue) => xdr.ScVal;
+export declare const encodeSwapVenue: (venue: StellarSwapVenue) => xdr.ScVal;
 /**
- * Encode the controller-facing `AggregatorSwap` struct
- * (`{ paths: Vec<SwapPath>, total_min_out: i128 }`).
- *
- * `SwapPath` is the PPM-split shape: each path declares `split_ppm`
- * (parts-per-million share of the batch's total input) and a `hops` chain.
+ * Encode the aggregator router's decoded `StrategyPayload` struct. The caller
+ * usually receives this as quote `routeXdr`; this helper is for tests and for
+ * callers that construct routes locally.
  */
-export declare const encodeAggregatorSwap: (swap: StellarSwapStepsInput) => xdr.ScVal;
+export declare const encodeStrategyPayload: (payload: StellarStrategyPayloadInput) => xdr.ScVal;
+/** @deprecated Use `encodeStrategyPayload`. */
+export declare const encodeAggregatorSwap: (payload: StellarStrategyPayloadInput) => xdr.ScVal;
+export declare const encodeStrategyPayloadToBytes: (payload: StellarStrategyPayloadInput) => xdr.ScVal;
 /**
- * Validate the untyped `steps` field and narrow it to `AggregatorSwapDto`.
+ * Validate the untyped `steps` field and narrow it to `StrategyPayload`.
  * Throws if the caller passed the wrong shape so the failure surfaces at the
  * SDK boundary, not inside the Soroban host on-chain.
  */
-export declare const asStellarSwapSteps: (steps: unknown) => StellarSwapStepsInput;
+export declare const asStellarStrategyPayload: (steps: unknown) => StellarStrategyPayloadInput;
+/**
+ * Encode opaque strategy bytes for the lending controller. Accepted inputs:
+ *   - quote `routeXdr` base64 string
+ *   - `{ routeXdr }` / `{ swapXdr }`
+ *   - raw `Uint8Array` / `{ bytes }`
+ *   - decoded `StrategyPayload` object
+ */
+export declare const asStellarStrategySwapBytes: (steps: unknown) => xdr.ScVal;
+/** @deprecated Use `asStellarStrategyPayload` or `asStellarStrategySwapBytes`. */
+export declare const asStellarSwapSteps: (steps: unknown) => StellarStrategyPayloadInput;
 /**
  * Validate the untyped `data` field on FlashLoanArgs and narrow it to
  * Buffer / hex string for Soroban `Bytes` encoding.

package/dist/sdk/stellar/swap.d.ts

@@ -1,55 +1,70 @@
 /**
  * Stellar aggregator router direct-call transaction builder.
  *
- * Builds an unsigned XDR for `router.batch_execute(BatchSwap)` so a
- * user can swap A → B without involving the lending controller. The
- * `BatchSwap.sender` is filled with the caller's G-strkey (the user's
- * own SAC balances fund the swap and receive the output).
+ * Builds an unsigned XDR for
+ * `router.execute_strategy(sender, total_in, swap_xdr)` so a user can swap
+ * A -> B without involving the lending controller. The strategy route is
+ * opaque bytes: normally the quote response `routeXdr`, decoded into Soroban
+ * `Bytes` for the contract call.
  *
- * For lending strategies (multiply / swap_debt / swap_collateral /
- * repay_debt_with_collateral) the controller wraps the same payload
- * itself and sets `sender = current_contract_address` — those flows
- * use the strategy builders in `./lending.ts`, NOT this builder.
+ * Lending strategies use the builders in `./lending.ts`; they pass the same
+ * opaque route bytes to the controller, which forwards them to the aggregator.
  */
-import type { AggregatorSwapDto, StellarAggregatorQuoteResponseDto } from '@xoxno/types';
+import type { StellarAggregatorQuoteResponseDto } from '@xoxno/types';
 import type { BuiltStellarTx, StellarBuilderOptions } from './lending';
-export interface StellarBatchSwapBuilderOptions extends StellarBuilderOptions {
+import { type StellarStrategyPayloadInput, type StellarStrategySwapHopInput, type StellarStrategySwapInput, type StellarStrategySwapPathInput } from './scval-encode';
+export type StellarStrategyPayload = StellarStrategyPayloadInput;
+export type StellarStrategySwap = StellarStrategySwapInput;
+export type StellarStrategySwapHop = StellarStrategySwapHopInput;
+export type StellarStrategySwapPath = StellarStrategySwapPathInput;
+export interface StellarExecuteStrategyBuilderOptions extends StellarBuilderOptions {
     /**
      * Override the resolved aggregator router contract address. Normally
      * resolved from `STELLAR_AGGREGATOR_ROUTER[network]`.
      */
     routerAddress?: string;
     /**
-     * Total input amount the router will pull from `caller` once at the
-     * start of `batch_execute` (i128 decimal string). Per-path
-     * allocations are derived inside the router from each path's
-     * `splitPpm`. For a quote-derived swap, pass `quote.amountIn`.
+     * Total input amount passed to `execute_strategy` (i128 decimal string).
+     * For a quote-derived swap, pass `quote.amountIn`.
      */
     totalIn: string;
     /**
-     * Referral identifier embedded into the BatchSwap. Defaults to `0`
-     * (no referral / no fee — matches rs-aggregator MVX semantics).
-     * Non-zero IDs MUST be registered on-chain via `add_referral` or the
-     * router reverts at execution.
+     * Referral identifier used only when the `swap` input is a decoded
+     * `StrategyPayload` object and does not already include `referralId`.
+     * Quote `routeXdr` already contains the referral chosen by the quote server.
      */
     referralId?: number | string;
 }
+/** @deprecated Use `StellarExecuteStrategyBuilderOptions`. */
+export interface StellarBatchSwapBuilderOptions extends StellarExecuteStrategyBuilderOptions {
+}
+export declare const encodeStrategyPayloadToRouteXdr: (payload: StellarStrategyPayloadInput) => string;
 /**
- * Build an unsigned XDR for a direct user → aggregator router swap.
+ * Build an unsigned XDR for a direct user -> aggregator router swap.
  *
- * The `swap` payload (paths + total-min-out) comes straight from the
- * quote server; map a `StellarAggregatorQuoteResponseDto` to
- * `AggregatorSwapDto` via `mapQuoteResponseToAggregatorSwap` before
- * calling this. `opts.totalIn` is the authoritative input amount.
+ * Pass the quote response `routeXdr` string or `{ routeXdr }` directly when
+ * available. Decoded `StrategyPayload` objects are accepted for local tests and
+ * custom route builders.
  */
-export declare function buildStellarBatchSwapTx(opts: StellarBatchSwapBuilderOptions, swap: AggregatorSwapDto): BuiltStellarTx;
+export declare function buildStellarExecuteStrategyTx(opts: StellarExecuteStrategyBuilderOptions, swap: StellarStrategySwapInput): BuiltStellarTx;
 /**
- * Translate a quote-server response into the controller-facing
- * `AggregatorSwapDto`. Each path's `splitPpm` comes straight from the
- * server; the single-path fallback (when `paths` is omitted) gets the
- * full 1_000_000 weight.
- *
- * Throws if `amountOutMin` is missing — the controller refuses
- * unbounded swaps so the SDK rejects them at the boundary.
+ * @deprecated The router no longer exposes `batch_execute`; this wrapper now
+ * builds `execute_strategy(sender, total_in, swap_xdr)`.
+ */
+export declare function buildStellarBatchSwapTx(opts: StellarBatchSwapBuilderOptions, swap: StellarStrategySwapInput): BuiltStellarTx;
+/**
+ * Translate a quote-server response into the decoded `StrategyPayload` shape.
+ * Prefer `mapQuoteResponseToStrategySwap` when the quote includes `routeXdr`.
  */
-export declare function mapQuoteResponseToAggregatorSwap(quote: StellarAggregatorQuoteResponseDto): AggregatorSwapDto;
+export declare function mapQuoteResponseToStrategyPayload(quote: StellarAggregatorQuoteResponseDto, opts?: {
+    referralId?: number | string;
+}): StellarStrategyPayloadInput;
+/**
+ * Return the executable quote route when the API provided it; otherwise build
+ * the decoded fallback payload from hop/path fields.
+ */
+export declare function mapQuoteResponseToStrategySwap(quote: StellarAggregatorQuoteResponseDto, opts?: {
+    referralId?: number | string;
+}): StellarStrategySwapInput;
+/** @deprecated Use `mapQuoteResponseToStrategyPayload`. */
+export declare const mapQuoteResponseToAggregatorSwap: typeof mapQuoteResponseToStrategyPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xoxno/sdk-js",
-  "version": "1.0.119",
+  "version": "1.0.120",
   "description": "The SDK to interact with the XOXNO Protocol!",
   "type": "module",
   "exports": {