@xoxno/sdk-js 1.0.159 → 1.0.161

package/dist/sdk/stellar/lending-read-types.d.ts

@@ -0,0 +1,259 @@
+/**
+ * Stellar lending read-API response shapes.
+ *
+ * These interfaces mirror the api-v2 `stellar-lending` response DTOs 1:1. The
+ * SDK never imports from api-v2, so the shapes are duplicated here by hand. Doc
+ * field types that already live in `@xoxno/types/stellar-lending` (governance
+ * enums + proposal fields, the initial-payment multiplier) are imported rather
+ * than re-declared.
+ *
+ * Numeric `*Wad`/`*Ray`/`*ScaledRay` fields cross the wire as decimal strings
+ * (1e18 / 1e27 fixed-point); `*Short` fields are already human-readable numbers.
+ */
+import type { StellarGovernanceProposalField, StellarGovernanceProposalKind, StellarGovernanceProposalStatus, StellarGovernanceProposalTarget, StellarInitialPaymentMultiplier } from '@xoxno/types/stellar-lending';
+/** Side selector for an asset's markets table. */
+export type StellarLendingMarketSide = 'deposit' | 'borrow';
+/** Side selector for a reserve's top-holders list. */
+export type StellarLendingHoldersSide = 'deposits' | 'borrows';
+/** One (spoke, hub) market row for an asset's markets table. */
+export interface StellarAssetMarket {
+    spokeId: number;
+    hubId: number;
+    asset: string;
+    supplyApy: number;
+    borrowApy: number;
+    utilization: number;
+    suppliedShort: number;
+    borrowedShort: number;
+    availableLiquidityShort: number;
+    collateralFactorBps: number;
+    liquidationThresholdBps: number;
+    isCollateralizable: boolean;
+    isBorrowable: boolean;
+}
+/** Asset overview header: identity + protocol-wide aggregates + APY ranges. */
+export interface StellarAsset {
+    asset: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    usdPriceWad: string;
+    usdPriceShort: number;
+    totalDepositsUsd: string;
+    totalBorrowsUsd: string;
+    availableLiquidityUsd: string;
+    hubCount: number;
+    reserveCount: number;
+    minSupplyApy: number;
+    maxSupplyApy: number;
+    minBorrowApy: number;
+    maxBorrowApy: number;
+}
+/** One asset's liquidity on a hub, rendered as a hub opportunity row. */
+export interface StellarHubAssetRow {
+    hubId: number;
+    asset: string;
+    supplyApy: number;
+    borrowApy: number;
+    utilization: number;
+    suppliedShort: number;
+    borrowedShort: number;
+    availableLiquidityShort: number;
+    isFlashloanable: boolean;
+}
+/** Hub overview: header totals + per-asset liquidity opportunities. */
+export interface StellarHub {
+    hubId: number;
+    isActive: boolean;
+    name: string | null;
+    totalDepositsUsd: string;
+    totalBorrowsUsd: string;
+    availableLiquidityUsd: string;
+    utilization: number;
+    assetCount: number;
+    assets: StellarHubAssetRow[];
+}
+/** One reserve row within a spoke (risk truth joined with hub liquidity). */
+export interface StellarSpokeMarket {
+    spokeId: number;
+    hubId: number;
+    asset: string;
+    supplyApy: number;
+    borrowApy: number;
+    utilization: number;
+    availableLiquidityShort: number;
+    collateralFactorBps: number;
+    liquidationThresholdBps: number;
+    isCollateralizable: boolean;
+    isBorrowable: boolean;
+    paused: boolean;
+    frozen: boolean;
+}
+/** Spoke overview: header totals, connected hubs, and per-reserve market table. */
+export interface StellarSpoke {
+    spokeId: number;
+    isDeprecated: boolean;
+    name: string | null;
+    totalDepositsUsd: string;
+    totalBorrowsUsd: string;
+    assetCount: number;
+    connectedHubIds: number[];
+    connectedHubCount: number;
+    liquidationTargetHfWad: string;
+    liquidationBonusFactorBps: number;
+    markets: StellarSpokeMarket[];
+}
+/** Interest-rate-model curve (ray-scaled), sourced from the HubAsset doc. */
+export interface StellarReserveIrmCurve {
+    baseRateRay: string;
+    slope1Ray: string;
+    slope2Ray: string;
+    slope3Ray: string;
+    optimalUtilizationRay: string;
+    midUtilizationRay: string;
+    maxUtilizationRay: string;
+    maxBorrowRateRay: string;
+    reserveFactorBps: number;
+}
+/**
+ * Reserve detail page: one asset, in one spoke, on one hub. Merges liquidity
+ * truth (HubAsset), risk truth (SpokeAsset) and the spoke's liquidation curve.
+ */
+export interface StellarReserve {
+    spokeId: number;
+    hubId: number;
+    asset: string;
+    supplyApy: number;
+    borrowApy: number;
+    utilization: number;
+    suppliedShort: number;
+    borrowedShort: number;
+    availableLiquidityShort: number;
+    supplyCapShort: number;
+    borrowCapShort: number;
+    depositCapFilledPct: number;
+    borrowCapFilledPct: number;
+    isFlashloanable: boolean;
+    flashloanFeeBps: number;
+    collateralFactorBps: number;
+    liquidationThresholdBps: number;
+    liquidationPenaltyBps: number;
+    liquidationFeesBps: number;
+    isCollateralizable: boolean;
+    isBorrowable: boolean;
+    paused: boolean;
+    frozen: boolean;
+    useAsCollateral: boolean;
+    targetHealthFactorWad: string;
+    healthFactorForMaxBonusWad: string;
+    liquidationBonusFactorBps: number;
+    irm: StellarReserveIrmCurve;
+    supportedCollateral: string[];
+    borrowable: string[];
+}
+export interface StellarTopHolder {
+    owner: string;
+    accountId: string;
+    scaledRay: string;
+    amountShort: number;
+    sharePct: number;
+}
+/** Top holders of a reserve, for one side (deposits or borrows). */
+export interface StellarTopHolders {
+    spokeId: number;
+    hubId: number;
+    asset: string;
+    side: StellarLendingHoldersSide;
+    totalScaledRay: string;
+    holders: StellarTopHolder[];
+}
+/** One account's position in one reserve. */
+export interface StellarAccountPosition {
+    accountId: string;
+    owner: string;
+    spokeId: number;
+    hubId: number;
+    asset: string;
+    positionMode: number;
+    supplyScaledRay: string;
+    borrowScaledRay: string;
+    supplyIndexRay: string | null;
+    borrowIndexRay: string | null;
+    entryLtvBps: number;
+    entryLiquidationThresholdBps: number;
+    entryLiquidationBonusBps: number;
+    entryLiquidationFeesBps: number;
+    initialPaymentMultiplier: StellarInitialPaymentMultiplier | null;
+    updatedAt: number;
+    ledger: number;
+}
+/** All positions for an owner (cross-spoke/hub portfolio) or one account. */
+export interface StellarAccountPositions {
+    positions: StellarAccountPosition[];
+}
+/** A timelock governance proposal on the Stellar lending governance contract. */
+export interface StellarGovernanceProposal {
+    operationId: string;
+    kind: StellarGovernanceProposalKind;
+    status: StellarGovernanceProposalStatus;
+    target: StellarGovernanceProposalTarget;
+    targetAddress: string;
+    functionName: string;
+    summary: string;
+    fields: StellarGovernanceProposalField[];
+    assetAddress?: string;
+    assetSymbol?: string;
+    proposer: string;
+    scheduledLedger: number;
+    readyLedger: number;
+    delayLedgers: number;
+    expiresLedger: number;
+    executedLedger?: number;
+    cancelledLedger?: number;
+    scheduledAt: number;
+    executedAt?: number;
+    cancelledAt?: number;
+    scheduledTxHash: string;
+    executedTxHash?: string;
+    cancelledTxHash?: string;
+}
+/** Cursor-paginated page of governance proposals. */
+export interface StellarGovernanceProposalsPage {
+    resources: StellarGovernanceProposal[];
+    hasMoreResults: boolean;
+    continuationToken: string;
+}
+/** One binned market-snapshot point for a graph series. */
+export interface StellarMarketGraphPoint {
+    timestamp: string;
+    hubId: number;
+    spokeId: number | null;
+    token: string;
+    supplyApy: number;
+    borrowApy: number;
+    utilization: number;
+    totalDepositsUsd: number;
+    totalBorrowsUsd: number;
+    availableLiquidityUsd: number;
+    usdPrice: number;
+}
+/** One binned activity-derived fee/flash point. */
+export interface StellarFeeGraphPoint {
+    timestamp: string;
+    feeShort: number;
+    usd: number;
+}
+/** A market-history graph: binned snapshot points (+ optional fee series). */
+export interface StellarMarketGraph {
+    points: StellarMarketGraphPoint[];
+    fees?: StellarFeeGraphPoint[];
+}
+/** Time-window + bin selector shared by every graph read. */
+export interface StellarMarketGraphQuery {
+    /** Inclusive window start (ISO-8601). */
+    from: string;
+    /** Exclusive window end (ISO-8601). */
+    to: string;
+    /** Bin width as a timespan string (e.g. `1h`, `1d`). */
+    bin: string;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Stellar lending read surface.
+ *
+ * Hand-written typed wrappers over the api-v2 `stellar-lending` GET routes
+ * (this is intentionally NOT part of the swagger-generated read SDK). Each
+ * function takes a `XOXNOClient` plus typed params and resolves to the mirrored
+ * response shape from `./lending-read-types`. A `stellarLendingRead(client)`
+ * factory binds the client once for ergonomic call sites.
+ *
+ * HTTP plumbing (base URL, query-string assembly, error mapping, caching) is
+ * delegated to `XOXNOClient.fetchWithTimeout`, the same wrapper the generated
+ * SDK uses.
+ */
+import type { OurRequestInit, XOXNOClient } from '../../utils/api';
+import type { StellarAccountPositions, StellarAsset, StellarAssetMarket, StellarGovernanceProposalsPage, StellarHub, StellarLendingHoldersSide, StellarLendingMarketSide, StellarMarketGraph, StellarMarketGraphQuery, StellarReserve, StellarSpoke, StellarTopHolders } from './lending-read-types';
+/** Reserve detail: one asset, in one spoke, on one hub. */
+export declare const getStellarReserve: (client: XOXNOClient, spokeId: number, hubId: number, asset: string, init?: OurRequestInit) => Promise<StellarReserve>;
+/** Top holders of a reserve, for one side (deposits or borrows). */
+export declare const getStellarReserveHolders: (client: XOXNOClient, spokeId: number, hubId: number, asset: string, side: StellarLendingHoldersSide, init?: OurRequestInit) => Promise<StellarTopHolders>;
+/** Asset overview: header totals + APY ranges. */
+export declare const getStellarAsset: (client: XOXNOClient, asset: string, init?: OurRequestInit) => Promise<StellarAsset>;
+/** Asset markets (per spoke/hub) for one side. */
+export declare const getStellarAssetMarkets: (client: XOXNOClient, asset: string, side: StellarLendingMarketSide, init?: OurRequestInit) => Promise<StellarAssetMarket[]>;
+/** Hub overview: totals + per-asset opportunities. */
+export declare const getStellarHub: (client: XOXNOClient, hubId: number, init?: OurRequestInit) => Promise<StellarHub>;
+/** Spoke overview: totals + connected hubs + per-reserve markets. */
+export declare const getStellarSpoke: (client: XOXNOClient, spokeId: number, init?: OurRequestInit) => Promise<StellarSpoke>;
+/** All positions for an owner (cross-partition portfolio). */
+export declare const getStellarUserPositions: (client: XOXNOClient, owner: string, init?: OurRequestInit) => Promise<StellarAccountPositions>;
+/** All positions for a single account (single-partition). */
+export declare const getStellarAccountPositions: (client: XOXNOClient, accountId: string, init?: OurRequestInit) => Promise<StellarAccountPositions>;
+/** Governance proposals (cursor-paginated). */
+export declare const getStellarGovernanceProposals: (client: XOXNOClient, opts?: {
+    top?: number;
+    continuationToken?: string;
+}, init?: OurRequestInit) => Promise<StellarGovernanceProposalsPage>;
+/** Asset market-history graph. */
+export declare const getStellarAssetGraph: (client: XOXNOClient, asset: string, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+/** Hub market-history graph. */
+export declare const getStellarHubGraph: (client: XOXNOClient, hubId: number, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+/** Spoke market-history graph. */
+export declare const getStellarSpokeGraph: (client: XOXNOClient, spokeId: number, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+/** Reserve market-history graph (+ fee series). */
+export declare const getStellarReserveGraph: (client: XOXNOClient, spokeId: number, hubId: number, asset: string, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+/**
+ * Client-bound Stellar lending read namespace. Binds `client` once so call
+ * sites read `read.reserve(spokeId, hubId, asset)` instead of threading the
+ * client through every call.
+ */
+export declare const stellarLendingRead: (client: XOXNOClient) => {
+    reserve: (spokeId: number, hubId: number, asset: string, init?: OurRequestInit) => Promise<StellarReserve>;
+    reserveHolders: (spokeId: number, hubId: number, asset: string, side: StellarLendingHoldersSide, init?: OurRequestInit) => Promise<StellarTopHolders>;
+    asset: (asset: string, init?: OurRequestInit) => Promise<StellarAsset>;
+    assetMarkets: (asset: string, side: StellarLendingMarketSide, init?: OurRequestInit) => Promise<StellarAssetMarket[]>;
+    hub: (hubId: number, init?: OurRequestInit) => Promise<StellarHub>;
+    spoke: (spokeId: number, init?: OurRequestInit) => Promise<StellarSpoke>;
+    userPositions: (owner: string, init?: OurRequestInit) => Promise<StellarAccountPositions>;
+    accountPositions: (accountId: string, init?: OurRequestInit) => Promise<StellarAccountPositions>;
+    governanceProposals: (opts?: {
+        top?: number;
+        continuationToken?: string;
+    }, init?: OurRequestInit) => Promise<StellarGovernanceProposalsPage>;
+    assetGraph: (asset: string, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+    hubGraph: (hubId: number, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+    spokeGraph: (spokeId: number, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+    reserveGraph: (spokeId: number, hubId: number, asset: string, query: StellarMarketGraphQuery, init?: OurRequestInit) => Promise<StellarMarketGraph>;
+};
+export type StellarLendingRead = ReturnType<typeof stellarLendingRead>;
+export * from './lending-read-types';

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

@@ -15,7 +15,6 @@
  * `rpc.Server.prepareTransaction` (simulation + Soroban footprint/auth/resource
  * fee) before handing the XDR to the wallet to sign.
  */
-import type { BorrowArgs, FlashLoanArgs, LiquidateArgs, MigrateFromBlendArgs, 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';
@@ -79,74 +78,158 @@ export type { StellarSwapVenue } from './scval-encode';
  * does this via `rpc.Server.prepareTransaction`.
  */
 export declare function buildTx(opts: StellarBuilderOptions, method: string, params: xdr.ScVal[]): BuiltStellarTx;
-export interface StellarTokenAmount {
-    token: string;
+/** A `(hub_id, asset)` coordinate — the `HubAssetKey` struct, builder-side. */
+export interface StellarHubAsset {
+    hubId: number;
+    asset: string;
+}
+/** A `HubAssetKey` paired with an i128 decimal-string amount. */
+export interface StellarHubAssetAmount extends StellarHubAsset {
     amount: string;
 }
+export interface StellarSupplyArgs extends StellarHubAssetAmount {
+    /** Existing account id; omit / `0` opens a new account. */
+    accountNonce?: number;
+    /** Risk spoke the (new) account binds to; defaults to the canonical spoke 0. */
+    spokeId?: number;
+}
 export interface StellarSupplyBatchArgs {
     accountNonce?: number;
-    eModeCategory?: number;
-    assets: ReadonlyArray<StellarTokenAmount>;
+    spokeId?: number;
+    assets: ReadonlyArray<StellarHubAssetAmount>;
+}
+export interface StellarBorrowArgs extends StellarHubAssetAmount {
+    accountNonce: number;
+    /** Optional recipient override (`C...`/`G...`); debt is recorded on the account. */
+    to?: string;
 }
 export interface StellarBorrowBatchArgs {
     accountNonce: number;
-    borrows: ReadonlyArray<StellarTokenAmount>;
+    borrows: ReadonlyArray<StellarHubAssetAmount>;
+    to?: string;
 }
-export interface StellarWithdrawBatchArgs {
+export interface StellarWithdrawArgs extends StellarHubAssetAmount {
     accountNonce: number;
-    withdrawals: ReadonlyArray<StellarTokenAmount>;
     /**
      * Optional recipient override (`C...` or `G...`). The pool pays the
      * withdrawn tokens to this address instead of the caller. Omit for the
      * standard flow — the contract arg is still sent, encoded as
-     * `Option::None` (ScVal void), which the controller resolves to the
-     * caller.
+     * `Option::None` (ScVal void), which the controller resolves to the caller.
      */
     to?: string;
 }
+export interface StellarWithdrawBatchArgs {
+    accountNonce: number;
+    withdrawals: ReadonlyArray<StellarHubAssetAmount>;
+    to?: string;
+}
+export interface StellarRepayArgs extends StellarHubAssetAmount {
+    accountNonce: number;
+}
 export interface StellarRepayBatchArgs {
     accountNonce: number;
-    payments: ReadonlyArray<StellarTokenAmount>;
+    payments: ReadonlyArray<StellarHubAssetAmount>;
+}
+export interface StellarLiquidateArgs {
+    accountNonce: number;
+    debtPayments: ReadonlyArray<StellarHubAssetAmount>;
+}
+export interface StellarFlashLoanArgs extends StellarHubAsset {
+    amount: string;
+    receiver: string;
+    data: string | Uint8Array;
+}
+export interface StellarMultiplyArgs {
+    accountNonce?: number;
+    spokeId?: number;
+    collateral: StellarHubAsset;
+    debtToFlashLoan: string;
+    debt: StellarHubAsset;
+    /** `PositionMode` repr(u32). */
+    mode: number;
+    steps: StellarSwapStepsInput;
+    initialPayment?: StellarHubAssetAmount;
+    convertSwap?: StellarSwapStepsInput;
+}
+export interface StellarSwapDebtArgs {
+    accountNonce: number;
+    existingDebt: StellarHubAsset;
+    newDebtAmount: string;
+    newDebt: StellarHubAsset;
+    steps: StellarSwapStepsInput;
+}
+export interface StellarSwapCollateralArgs {
+    accountNonce: number;
+    current: StellarHubAsset;
+    fromAmount: string;
+    newCollateral: StellarHubAsset;
+    steps: StellarSwapStepsInput;
+}
+export interface StellarRepayDebtWithCollateralArgs {
+    accountNonce: number;
+    collateral: StellarHubAsset;
+    collateralAmount: string;
+    debt: StellarHubAsset;
+    steps: StellarSwapStepsInput;
+    closePosition: boolean;
 }
 /**
- * supply(caller, account_id: u64, e_mode_category: u32, assets: Vec<(Address, i128)>)
+ * `migrate_from_blend` references the *Blend* pool's bare-`Address` assets, so
+ * collateral / supply / debt stay token-keyed; only the account's risk spoke
+ * (`spoke_id`) crosses on the XOXNO side.
  */
-export declare function buildStellarSupplyBatchTx(opts: StellarBuilderOptions, args: StellarSupplyBatchArgs): BuiltStellarTx;
+export interface StellarMigrateFromBlendArgs {
+    accountId: number | string;
+    spokeId: number;
+    blendPool: string;
+    collateralTokens: ReadonlyArray<string>;
+    supplyTokens: ReadonlyArray<string>;
+    debtCaps: ReadonlyArray<{
+        token: string;
+        cap: string;
+    }>;
+}
 /**
- * @xoxno/types `SupplyArgs` is a single-asset shape; the Stellar contract
- * expects a batch — we wrap the single asset in a 1-element Vec.
+ * supply(caller, account_id: u64, spoke_id: u32, assets: Vec<(HubAssetKey, i128)>)
  */
-export declare function buildStellarSupplyTx(opts: StellarBuilderOptions, args: SupplyArgs): BuiltStellarTx;
-export declare function buildStellarBorrowBatchTx(opts: StellarBuilderOptions, args: StellarBorrowBatchArgs): BuiltStellarTx;
+export declare function buildStellarSupplyBatchTx(opts: StellarBuilderOptions, args: StellarSupplyBatchArgs): BuiltStellarTx;
+/** Single-asset `supply` — wraps the asset in a 1-element batch. */
+export declare function buildStellarSupplyTx(opts: StellarBuilderOptions, args: StellarSupplyArgs): BuiltStellarTx;
 /**
- * borrow(caller, account_id: u64, borrows: Vec<(Address, i128)>)
+ * borrow(caller, account_id: u64, borrows: Vec<(HubAssetKey, i128)>,
+ * to: Option<Address>) — `to` is always sent; absent means the caller
+ * receives the funds.
  */
-export declare function buildStellarBorrowTx(opts: StellarBuilderOptions, args: BorrowArgs): BuiltStellarTx;
-export declare function buildStellarWithdrawBatchTx(opts: StellarBuilderOptions, args: StellarWithdrawBatchArgs): BuiltStellarTx;
+export declare function buildStellarBorrowBatchTx(opts: StellarBuilderOptions, args: StellarBorrowBatchArgs): BuiltStellarTx;
+/** Single-asset `borrow`. */
+export declare function buildStellarBorrowTx(opts: StellarBuilderOptions, args: StellarBorrowArgs): BuiltStellarTx;
 /**
- * withdraw(caller, account_id: u64, withdrawals: Vec<(Address, i128)>,
+ * withdraw(caller, account_id: u64, withdrawals: Vec<(HubAssetKey, i128)>,
  * to: Option<Address>) — `to` is always sent; absent means the caller
  * receives the funds.
  */
-export declare function buildStellarWithdrawTx(opts: StellarBuilderOptions, args: WithdrawArgs): BuiltStellarTx;
-export declare function buildStellarRepayBatchTx(opts: StellarBuilderOptions, args: StellarRepayBatchArgs): BuiltStellarTx;
+export declare function buildStellarWithdrawBatchTx(opts: StellarBuilderOptions, args: StellarWithdrawBatchArgs): BuiltStellarTx;
+/** Single-asset `withdraw`. */
+export declare function buildStellarWithdrawTx(opts: StellarBuilderOptions, args: StellarWithdrawArgs): BuiltStellarTx;
 /**
- * repay(caller, account_id: u64, payments: Vec<(Address, i128)>)
+ * repay(caller, account_id: u64, payments: Vec<(HubAssetKey, i128)>)
  */
-export declare function buildStellarRepayTx(opts: StellarBuilderOptions, args: RepayArgs): BuiltStellarTx;
+export declare function buildStellarRepayBatchTx(opts: StellarBuilderOptions, args: StellarRepayBatchArgs): BuiltStellarTx;
+/** Single-asset `repay`. */
+export declare function buildStellarRepayTx(opts: StellarBuilderOptions, args: StellarRepayArgs): BuiltStellarTx;
 /**
- * liquidate(liquidator, account_id: u64, debt_payments: Vec<(Address, i128)>)
+ * liquidate(liquidator, account_id: u64, debt_payments: Vec<(HubAssetKey, i128)>)
  */
-export declare function buildStellarLiquidateTx(opts: StellarBuilderOptions, args: LiquidateArgs): BuiltStellarTx;
+export declare function buildStellarLiquidateTx(opts: StellarBuilderOptions, args: StellarLiquidateArgs): BuiltStellarTx;
 /**
- * flash_loan(caller, asset, amount: i128, receiver, data: Bytes)
+ * flash_loan(caller, asset: HubAssetKey, amount: i128, receiver, data: Bytes)
  */
-export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, args: FlashLoanArgs): BuiltStellarTx;
+export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, args: StellarFlashLoanArgs): BuiltStellarTx;
 /**
  * Build a `migrate_from_blend` controller invocation: atomically moves a Blend
  * V2 position (collateral + supply + debt) into XOXNO at zero flash-loan fee.
  *
- * ABI: `migrate_from_blend(caller, account_id, e_mode_category, blend_pool,
+ * ABI: `migrate_from_blend(caller, account_id, spoke_id, blend_pool,
  * collateral_assets, supply_assets, debt_caps: Vec<(Address, i128)>)`. Pass
  * `accountId = "0"` to open a new account. Each debt cap should slightly exceed
  * the live Blend debt — Blend refunds the excess, reconciled on-chain.
@@ -155,31 +238,31 @@ export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, arg
  * user)` authorization is materialized by `prepareTransaction` (simulation) and
  * signed by the wallet over the whole envelope.
  */
-export declare function buildStellarMigrateFromBlendTx(opts: StellarBuilderOptions, args: MigrateFromBlendArgs): BuiltStellarTx;
+export declare function buildStellarMigrateFromBlendTx(opts: StellarBuilderOptions, args: StellarMigrateFromBlendArgs): BuiltStellarTx;
 /**
- * multiply(caller, account_id, e_mode_category, collateral_token,
- *          debt_to_flash_loan: i128, debt_token, mode: PositionMode,
- *          swap: Bytes, initial_payment: Option<(Address, i128)>,
+ * multiply(caller, account_id, spoke_id, collateral: HubAssetKey,
+ *          debt_to_flash_loan: i128, debt: HubAssetKey, mode: PositionMode,
+ *          swap: Bytes, initial_payment: Option<(HubAssetKey, 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
  * converting it into the collateral token; both omit to Soroban `Void`.
  */
-export declare function buildStellarMultiplyTx(opts: StellarBuilderOptions, args: MultiplyArgs): BuiltStellarTx;
+export declare function buildStellarMultiplyTx(opts: StellarBuilderOptions, args: StellarMultiplyArgs): BuiltStellarTx;
 /**
- * swap_debt(caller, account_id, existing_debt_token, new_debt_amount: i128,
- *           new_debt_token, steps: Bytes)
+ * swap_debt(caller, account_id, existing_debt: HubAssetKey, amount: i128,
+ *           new_debt: HubAssetKey, swap: Bytes)
  */
-export declare function buildStellarSwapDebtTx(opts: StellarBuilderOptions, args: SwapDebtArgs): BuiltStellarTx;
+export declare function buildStellarSwapDebtTx(opts: StellarBuilderOptions, args: StellarSwapDebtArgs): BuiltStellarTx;
 /**
- * swap_collateral(caller, account_id, current_collateral, from_amount: i128,
- *                 new_collateral, steps: Bytes)
+ * swap_collateral(caller, account_id, current: HubAssetKey, amount: i128,
+ *                 new: HubAssetKey, swap: Bytes)
  */
-export declare function buildStellarSwapCollateralTx(opts: StellarBuilderOptions, args: SwapCollateralArgs): BuiltStellarTx;
+export declare function buildStellarSwapCollateralTx(opts: StellarBuilderOptions, args: StellarSwapCollateralArgs): BuiltStellarTx;
 /**
- * repay_debt_with_collateral(caller, account_id, collateral_token,
- *                            collateral_amount: i128, debt_token,
- *                            steps: Bytes, close_position: bool)
+ * repay_debt_with_collateral(caller, account_id, collateral: HubAssetKey,
+ *                            collateral_amount: i128, debt: HubAssetKey,
+ *                            swap: Bytes, close_position: bool)
  */
-export declare function buildStellarRepayDebtWithCollateralTx(opts: StellarBuilderOptions, args: RepayDebtWithCollateralArgs): BuiltStellarTx;
+export declare function buildStellarRepayDebtWithCollateralTx(opts: StellarBuilderOptions, args: StellarRepayDebtWithCollateralArgs): BuiltStellarTx;

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

@@ -73,6 +73,26 @@ export declare const tupleAddrAmountVec: (entries: Array<{
     token: string;
     amount: string;
 }>) => xdr.ScVal;
+/**
+ * Encode a `HubAssetKey` `#[contracttype]` struct — the `(hub_id, asset)`
+ * coordinate that keys liquidity and positions on the multi-hub controller.
+ * Emitted as an ScVal map with symbol keys in lexicographic order
+ * (`asset`, then `hub_id`).
+ */
+export declare const hubAsset: (hubId: number, asset: string) => xdr.ScVal;
+/**
+ * Encode a single Soroban tuple `(HubAssetKey, i128)` as a 2-element `scvVec`.
+ */
+export declare const tupleHubAssetAmount: (hubId: number, asset: string, amount: string) => xdr.ScVal;
+/**
+ * Encode `Vec<(HubAssetKey, i128)>` — the multi-hub batch payload carried by
+ * `supply` / `borrow` / `withdraw` / `repay` / `liquidate`.
+ */
+export declare const tupleHubAssetAmountVec: (entries: Array<{
+    hubId: number;
+    asset: string;
+    amount: string;
+}>) => xdr.ScVal;
 /**
  * Encode a Soroban `struct` — at the XDR level, structs are maps with
  * `Symbol` keys in **lexicographic order** of field names.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xoxno/sdk-js",
-  "version": "1.0.159",
+  "version": "1.0.161",
   "description": "The SDK to interact with the XOXNO Protocol!",
   "type": "module",
   "exports": {
@@ -13,6 +13,16 @@
         "types": "./dist/cjs/index.d.ts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./stellar-lending": {
+      "import": {
+        "types": "./dist/sdk/stellar/index.d.ts",
+        "default": "./dist/sdk/stellar/index.esm.js"
+      },
+      "require": {
+        "types": "./dist/cjs/sdk/stellar/index.d.ts",
+        "default": "./dist/sdk/stellar/index.cjs"
+      }
     }
   },
   "types": "./dist/index.d.ts",
@@ -104,7 +114,7 @@
   "dependencies": {
     "@multiversx/sdk-core": "^15.3.2",
     "@multiversx/sdk-network-providers": "^2.9.3",
-    "@xoxno/types": "^1.0.426"
+    "@xoxno/types": "^1.0.428"
   },
   "peerDependencies": {
     "@stellar/stellar-sdk": ">=15.0.0 <17.0.0"