@xoxno/sdk-js 1.0.113 → 1.0.115

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

@@ -0,0 +1,14 @@
+/**
+ * Snapshot + structural tests for the Stellar lending ADMIN / CONFIG / KEEPER /
+ * ACCESS transaction builders.
+ *
+ * Beyond the function-name / arg-count / determinism / snapshot guards shared
+ * with `lending.test.ts`, this suite decodes the complex `#[contracttype]`
+ * struct args (`MarketOracleConfigInput`, `AssetConfigRaw`) back out of the XDR
+ * and asserts the ScMap keys are ascending-sorted (the Soroban host requires
+ * sorted symbol keys) and that the oracle union / custom-option tags are
+ * well-formed. The encoders reuse the same `scStruct` already proven on-chain
+ * by the production swap builders; for the all-lowercase snake_case field sets
+ * used here, JS lexicographic order matches Soroban's symbol collation.
+ */
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Decoder tests locked against REAL captured event XDR.
+ *
+ * `fixtures/lending-events.json` was produced by publishing every controller
+ * `#[contractevent]` in a soroban-sdk 26 test env and serializing each event's
+ * topics + `data` to base64 XDR via `ScVal::to_xdr_base64` — byte-identical to
+ * what Soroban RPC `getEvents` delivers. These tests prove the decoders match
+ * on-chain reality (not a hand-built assumption) and that the four legacy
+ * consumer bugs are fixed.
+ */
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ * Byte-identical parity guard for the Stellar lending activity-id primitives.
+ *
+ * Expected values are computed from api-v2's verbatim formula (the source these
+ * functions were ported from). Both consumers route their id derivation through
+ * these functions, so locking the outputs here is what makes the Phase 4
+ * activity-indexing consolidation safe — divergence shows up as a failing
+ * assertion, not as duplicated Cosmos docs.
+ */
+export {};

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

@@ -0,0 +1,187 @@
+/**
+ * Stellar Soroban lending ADMIN / CONFIG / KEEPER / ACCESS transaction builders.
+ *
+ * Companion to `lending.ts` (user operations). Every state-changing controller
+ * entry point that is not a plain user op lives here, 1:1 with the controller
+ * `#[contractimpl]` methods in `rs-lending-xlm/contracts/controller/src/{access,
+ * config,router}.rs`. Each builder returns an unsigned `BuiltStellarTx` XDR.
+ *
+ * Auth model:
+ *   - `#[only_owner]` methods take no `caller` param — the tx source
+ *     (`opts.caller`) must be the contract owner.
+ *   - `#[only_role(caller, "ROLE")]` and caller-taking methods encode
+ *     `opts.caller` as the leading `Address` arg; that account must hold the
+ *     role and sign the tx.
+ *
+ * The complex contract structs (`InterestRateModel`, `MarketParamsRaw`,
+ * `AssetConfigRaw`, `PositionLimits`, `MarketOracleConfigInput`) are encoded
+ * here from their `@xoxno/types` builder-input DTOs.
+ */
+import type { AssetConfigRawDto, InterestRateModelDto, MarketOracleConfigInputDto, MarketParamsRawDto, OracleSourceConfigInputDto, PositionLimitsDto } from '@xoxno/types';
+import { type BuiltStellarTx, type StellarBuilderOptions } from './lending';
+import { xdr } from '@stellar/stellar-sdk';
+/** `InterestRateModel` — 8 RAY rates + reserve factor bps. */
+export declare const encodeInterestRateModel: (m: InterestRateModelDto) => xdr.ScVal;
+/** `MarketParamsRaw` — `InterestRateModel` plus the pool asset identity. */
+export declare const encodeMarketParamsRaw: (p: MarketParamsRawDto) => xdr.ScVal;
+/** `AssetConfigRaw` — 17 risk/limit fields. */
+export declare const encodeAssetConfigRaw: (c: AssetConfigRawDto) => xdr.ScVal;
+/** `PositionLimits` — per-account supply/borrow position caps. */
+export declare const encodePositionLimits: (l: PositionLimitsDto) => xdr.ScVal;
+/** `OracleSourceConfigInput` data-enum — `Reflector(...)` | `RedStone(...)`. */
+export declare const encodeOracleSourceConfigInput: (src: OracleSourceConfigInputDto) => xdr.ScVal;
+/** `MarketOracleConfigInput` — strategy + primary/anchor sources + sanity bounds. */
+export declare const encodeMarketOracleConfigInput: (cfg: MarketOracleConfigInputDto) => xdr.ScVal;
+export interface RoleGrantArgs {
+    account: string;
+    role: string;
+}
+export interface TransferOwnershipArgs {
+    newOwner: string;
+    liveUntilLedger: number;
+}
+export interface EditAssetConfigArgs {
+    asset: string;
+    config: AssetConfigRawDto;
+}
+export interface EModeCategoryEditArgs {
+    id: number;
+    ltv: number;
+    threshold: number;
+    bonus: number;
+}
+export interface EModeAssetArgs {
+    asset: string;
+    categoryId: number;
+    canCollateral: boolean;
+    canBorrow: boolean;
+}
+export interface RemoveEModeAssetArgs {
+    asset: string;
+    categoryId: number;
+}
+export interface ConfigureMarketOracleArgs {
+    asset: string;
+    config: MarketOracleConfigInputDto;
+}
+export interface EditOracleToleranceArgs {
+    asset: string;
+    firstTolerance: number;
+    lastTolerance: number;
+}
+export interface CreateLiquidityPoolArgs {
+    asset: string;
+    params: MarketParamsRawDto;
+    config: AssetConfigRawDto;
+}
+export interface UpgradeLiquidityPoolParamsArgs {
+    asset: string;
+    params: InterestRateModelDto;
+}
+export interface UpgradeLiquidityPoolArgs {
+    asset: string;
+    wasmHash: string;
+}
+export interface RewardEntry {
+    token: string;
+    amount: string;
+}
+export interface UpdateAccountThresholdArgs {
+    asset: string;
+    hasRisks: boolean;
+    accountNonces: number[];
+}
+/** upgrade(new_wasm_hash: BytesN<32>) */
+export declare function buildStellarUpgradeControllerTx(opts: StellarBuilderOptions, args: {
+    wasmHash: string;
+}): BuiltStellarTx;
+/** migrate(new_version: u32) */
+export declare function buildStellarMigrateTx(opts: StellarBuilderOptions, args: {
+    newVersion: number;
+}): BuiltStellarTx;
+/** pause() */
+export declare function buildStellarPauseTx(opts: StellarBuilderOptions): BuiltStellarTx;
+/** unpause() */
+export declare function buildStellarUnpauseTx(opts: StellarBuilderOptions): BuiltStellarTx;
+/** grant_role(account: Address, role: Symbol) */
+export declare function buildStellarGrantRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs): BuiltStellarTx;
+/** revoke_role(account: Address, role: Symbol) */
+export declare function buildStellarRevokeRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs): BuiltStellarTx;
+/** transfer_ownership(new_owner: Address, live_until_ledger: u32) */
+export declare function buildStellarTransferOwnershipTx(opts: StellarBuilderOptions, args: TransferOwnershipArgs): BuiltStellarTx;
+/** accept_ownership() */
+export declare function buildStellarAcceptOwnershipTx(opts: StellarBuilderOptions): BuiltStellarTx;
+/** set_aggregator(addr: Address) — #[only_owner] */
+export declare function buildStellarSetAggregatorTx(opts: StellarBuilderOptions, args: {
+    aggregator: string;
+}): BuiltStellarTx;
+/** set_accumulator(addr: Address) — #[only_owner] */
+export declare function buildStellarSetAccumulatorTx(opts: StellarBuilderOptions, args: {
+    accumulator: string;
+}): BuiltStellarTx;
+/** set_liquidity_pool_template(hash: BytesN<32>) — #[only_owner] */
+export declare function buildStellarSetLiquidityPoolTemplateTx(opts: StellarBuilderOptions, args: {
+    wasmHash: string;
+}): BuiltStellarTx;
+/** edit_asset_config(asset: Address, cfg: AssetConfigRaw) — #[only_owner] */
+export declare function buildStellarEditAssetConfigTx(opts: StellarBuilderOptions, args: EditAssetConfigArgs): BuiltStellarTx;
+/** set_position_limits(limits: PositionLimits) — #[only_owner] */
+export declare function buildStellarSetPositionLimitsTx(opts: StellarBuilderOptions, args: PositionLimitsDto): BuiltStellarTx;
+/** add_e_mode_category(ltv: u32, threshold: u32, bonus: u32) -> u32 — #[only_owner] */
+export declare function buildStellarAddEModeCategoryTx(opts: StellarBuilderOptions, args: {
+    ltv: number;
+    threshold: number;
+    bonus: number;
+}): BuiltStellarTx;
+/** edit_e_mode_category(id: u32, ltv: u32, threshold: u32, bonus: u32) — #[only_owner] */
+export declare function buildStellarEditEModeCategoryTx(opts: StellarBuilderOptions, args: EModeCategoryEditArgs): BuiltStellarTx;
+/** remove_e_mode_category(id: u32) — #[only_owner] */
+export declare function buildStellarRemoveEModeCategoryTx(opts: StellarBuilderOptions, args: {
+    id: number;
+}): BuiltStellarTx;
+/** add_asset_to_e_mode_category(asset, category_id, can_collateral, can_borrow) — #[only_owner] */
+export declare function buildStellarAddAssetToEModeCategoryTx(opts: StellarBuilderOptions, args: EModeAssetArgs): BuiltStellarTx;
+/** edit_asset_in_e_mode_category(asset, category_id, can_collateral, can_borrow) — #[only_owner] */
+export declare function buildStellarEditAssetInEModeCategoryTx(opts: StellarBuilderOptions, args: EModeAssetArgs): BuiltStellarTx;
+/** remove_asset_from_e_mode(asset: Address, category_id: u32) — #[only_owner] */
+export declare function buildStellarRemoveAssetFromEModeTx(opts: StellarBuilderOptions, args: RemoveEModeAssetArgs): BuiltStellarTx;
+/** approve_token(token: Address) — #[only_owner] */
+export declare function buildStellarApproveTokenTx(opts: StellarBuilderOptions, args: {
+    token: string;
+}): BuiltStellarTx;
+/** revoke_token(token: Address) — #[only_owner] */
+export declare function buildStellarRevokeTokenTx(opts: StellarBuilderOptions, args: {
+    token: string;
+}): BuiltStellarTx;
+/** configure_market_oracle(caller, asset, cfg) — #[only_role(caller, "ORACLE")] */
+export declare function buildStellarConfigureMarketOracleTx(opts: StellarBuilderOptions, args: ConfigureMarketOracleArgs): BuiltStellarTx;
+/** edit_oracle_tolerance(caller, asset, first_tolerance, last_tolerance) — #[only_role(caller, "ORACLE")] */
+export declare function buildStellarEditOracleToleranceTx(opts: StellarBuilderOptions, args: EditOracleToleranceArgs): BuiltStellarTx;
+/** disable_token_oracle(caller, asset) — #[only_role(caller, "ORACLE")] */
+export declare function buildStellarDisableTokenOracleTx(opts: StellarBuilderOptions, args: {
+    asset: string;
+}): BuiltStellarTx;
+/** update_indexes(caller, assets: Vec<Address>) — #[only_role(caller, "KEEPER")] */
+export declare function buildStellarUpdateIndexesTx(opts: StellarBuilderOptions, args: {
+    assets: string[];
+}): BuiltStellarTx;
+/** renew_account(caller, account_id: u64) */
+export declare function buildStellarRenewAccountTx(opts: StellarBuilderOptions, args: {
+    accountNonce: number;
+}): BuiltStellarTx;
+/** create_liquidity_pool(asset, params: MarketParamsRaw, config: AssetConfigRaw) -> Address — #[only_owner] */
+export declare function buildStellarCreateLiquidityPoolTx(opts: StellarBuilderOptions, args: CreateLiquidityPoolArgs): BuiltStellarTx;
+/** upgrade_liquidity_pool_params(asset, params: InterestRateModel) — #[only_owner] */
+export declare function buildStellarUpgradeLiquidityPoolParamsTx(opts: StellarBuilderOptions, args: UpgradeLiquidityPoolParamsArgs): BuiltStellarTx;
+/** upgrade_liquidity_pool(asset, new_wasm_hash: BytesN<32>) — #[only_owner] */
+export declare function buildStellarUpgradeLiquidityPoolTx(opts: StellarBuilderOptions, args: UpgradeLiquidityPoolArgs): BuiltStellarTx;
+/** claim_revenue(caller, assets: Vec<Address>) -> Vec<i128> — #[only_role(caller, "REVENUE")] */
+export declare function buildStellarClaimRevenueTx(opts: StellarBuilderOptions, args: {
+    assets: string[];
+}): BuiltStellarTx;
+/** add_rewards(caller, rewards: Vec<(Address, i128)>) — #[only_role(caller, "REVENUE")] */
+export declare function buildStellarAddRewardsTx(opts: StellarBuilderOptions, args: {
+    rewards: RewardEntry[];
+}): BuiltStellarTx;
+/** update_account_threshold(caller, asset, has_risks, account_ids: Vec<u64>) — #[only_role(caller, "KEEPER")] */
+export declare function buildStellarUpdateAccountThresholdTx(opts: StellarBuilderOptions, args: UpdateAccountThresholdArgs): BuiltStellarTx;

package/dist/sdk/stellar/events/decode.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Decoders for the 21 XOXNO Stellar lending controller `#[contractevent]`s.
+ *
+ * Public API is **base64-XDR-string in** — `decodeStellarLendingEvent(topicsB64,
+ * dataB64)` parses with the SDK's own bundled `@stellar/stellar-sdk`, so no live
+ * `xdr.ScVal` ever crosses the consumer boundary. This makes decoding immune to
+ * the dual-package hazard and to `@stellar/stellar-sdk` version skew between the
+ * SDK and its consumers (Soroban RPC `getEvents` already delivers `topic[]` and
+ * `value` as base64 XDR — pass them straight through).
+ *
+ * soroban-sdk 26 serializes every contractevent `data` as an `ScMap` keyed by
+ * field name (verified against real captured emissions, including single-field
+ * and batch events), so `scValToNative` yields a snake_case-keyed object with
+ * `bigint` for i128/u64, `number` for u32, strkey strings for addresses,
+ * strings for symbols, `null` for absent `Option`s, and arrays for `Vec`s.
+ *
+ * Bug fixes baked in vs the consumers' legacy decoders:
+ *   - the real `debt:ceiling_batch_update` is decoded (the single
+ *     `debt:ceiling_update` is dead on-chain but kept for completeness);
+ *   - `oracle:twap_degraded` is decoded;
+ *   - borrow-side deltas expose risk fields as `undefined` (not 0);
+ *   - no `liquidation_fees_bps` is read off position deltas (it does not exist).
+ */
+import type { StellarLendingDecodedEvent } from '@xoxno/types';
+/**
+ * Serialize a live `xdr.ScVal` to base64 XDR for the string-only decoder API.
+ * Use this if you hold parsed ScVals (e.g. from the high-level RPC client);
+ * `.toXDR` is wire-format/structural, so it is safe across SDK copies.
+ */
+export declare const toBase64Xdr: (scv: {
+    toXDR(format: "base64"): string;
+}) => string;
+/** Build the `"<domain>:<action>"` dispatch key from the event topic ScVals. */
+export declare const stellarLendingDispatchKey: (topicsB64: readonly string[]) => string;
+/** Topic keys this SDK can decode (the 21 controller contractevents). */
+export declare const STELLAR_LENDING_TOPICS: readonly string[];
+/**
+ * Decode a Stellar lending controller event from its base64-XDR topics and
+ * data (exactly as Soroban RPC `getEvents` delivers them). Returns `null` for a
+ * topic this SDK does not decode (e.g. access-control `role_granted` events),
+ * so consumers can skip unknown events without throwing.
+ */
+export declare function decodeStellarLendingEvent(topicsB64: readonly string[], dataB64: string): StellarLendingDecodedEvent | null;

package/dist/sdk/stellar/events/id.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Stellar lending activity-id derivation — the single owner of the inputs that
+ * compose `NftActivityDoc.id` (`${txHash}-${eventIdentifier}-${eventOrder}`).
+ *
+ * Both indexing consumers (xoxno-api-v2, xoxno-az-functions) MUST derive these
+ * inputs here so the activity ids they write to `NFT_ACTIVITY_DATA` are
+ * byte-identical — the hard gate for consolidating activity indexing into a
+ * single producer. Ported verbatim from api-v2's `stellar-lending-activity.mapper`.
+ *
+ * The activity-type string values mirror `@xoxno/types` `XoxnoLendingActivity`.
+ * They are inlined (not imported) because `@xoxno/types` does not re-export its
+ * enums on the top-level type surface and the SDK keeps that NestJS-coupled
+ * module out of its runtime bundle.
+ */
+/** Synthetic NFT collection ticker for Stellar lending accounts. */
+export declare const XOXNO_LENDING_STELLAR_TICKER = "XLENDXLM-a7c9f3";
+/**
+ * A child delta's contribution to `eventOrder`: `base * STRIDE + childIndex`.
+ * The stride bounds the number of child deltas per base event before two base
+ * events could collide.
+ */
+export declare const SYNTHETIC_EVENT_ORDER_STRIDE = 10000;
+/** `XoxnoLendingActivity` values used by the position activity mapping. */
+export type StellarLendingActivityType = 'lendingUpdateAccountPosition' | 'lendingLiquidateRepayDebt' | 'lendingLiquidateSeizeCollateral' | 'lendingUpdateAccountParameters';
+/**
+ * Synthetic NFT identifier for a Stellar lending account, e.g.
+ * `XLENDXLM-a7c9f3-2a` for account 42. The u64 account id is rendered as
+ * even-length lowercase hex.
+ */
+export declare function buildStellarLendingIdentifier(accountId: string): string;
+/**
+ * Extract the base event order from a Soroban RPC event id (`<ledger>-<index>`).
+ * Returns 0 when the id is malformed or has no index segment.
+ */
+export declare function extractEventOrder(eventId: string): number;
+/**
+ * Stable per-child ordering within one base event:
+ * `baseEventOrder * 10_000 + childIndex`. Keeps multiple deltas emitted by a
+ * single transaction deterministically ordered and collision-free.
+ */
+export declare function syntheticEventOrder(baseEventOrder: number, childIndex?: number): number;
+/**
+ * Map a position-delta `action` symbol to its `XoxnoLendingActivity` value.
+ * The tag list is authoritative in `rs-lending-xlm common/src/events.rs`.
+ */
+export declare function mapStellarPositionActivityType(action?: string): StellarLendingActivityType;

package/dist/sdk/stellar/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decode';
+export * from './id';

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

@@ -1,4 +1,6 @@
 export * from './contracts';
 export * from './lending';
+export * from './admin';
+export * from './events';
 export * from './quote';
 export * from './swap';

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

@@ -37,6 +37,7 @@
  * 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 { xdr } from '@stellar/stellar-sdk';
 import { type StellarNetwork } from './contracts';
 /**
  * Stellar `G...` public key of the caller (tx source account).
@@ -104,6 +105,15 @@ export type StellarSwapStepsInput = AggregatorSwapDto;
 export type StellarSwapHopInput = SwapHopDto;
 export type StellarSwapPathInput = SwapPathDto;
 export type StellarSwapVenue = SwapVenue;
+/**
+ * Assemble an unsigned XDR that invokes a single Soroban contract method.
+ *
+ * Uses a synthetic `Account(caller, sourceSequence)` — no RPC call. The
+ * returned XDR still needs preparation (simulation to populate Soroban
+ * footprint + auth entries + resource fees) before signing. The UI layer
+ * does this via `rpc.Server.prepareTransaction`.
+ */
+export declare function buildTx(opts: StellarBuilderOptions, method: string, params: xdr.ScVal[]): BuiltStellarTx;
 /**
  * supply(caller, account_id: u64, e_mode_category: u32, assets: Vec<(Address, i128)>)
  * @xoxno/types `SupplyArgs` is a single-asset shape; the Stellar contract
@@ -132,7 +142,13 @@ export declare function buildStellarLiquidateTx(opts: StellarBuilderOptions, arg
 export declare function buildStellarFlashLoanTx(opts: StellarBuilderOptions, args: FlashLoanArgs): BuiltStellarTx;
 /**
  * multiply(caller, account_id, e_mode_category, collateral_token,
- *          debt_to_flash_loan: i128, debt_token, mode: u32, steps: SwapSteps) -> u64
+ *          debt_to_flash_loan: i128, debt_token, mode: PositionMode,
+ *          swap: AggregatorSwap, initial_payment: Option<(Address, i128)>,
+ *          convert_swap: Option<AggregatorSwap>) -> 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;
 /**

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

@@ -0,0 +1,91 @@
+/**
+ * Shared Soroban `ScVal` encoding primitives for the Stellar lending SDK.
+ *
+ * Extracted verbatim from `lending.ts` so both the user-operation builders
+ * (`lending.ts`) and the admin/config builders (`admin.ts`) encode against one
+ * implementation. Behavior-preserving: the existing builder XDR snapshots must
+ * not change.
+ *
+ * i128/u128 values cross the boundary as decimal strings (`new ScInt(str)`).
+ * Addresses (Stellar `G...` accounts and Soroban `C...` contracts) encode via
+ * `new Address(str).toScVal()`. Soroban `#[contracttype]` structs are ScMaps
+ * with `Symbol` keys in ascending order — `scStruct` lex-sorts the field names,
+ * which matches Soroban's small-symbol collation for the all-lowercase
+ * snake_case field sets used here.
+ */
+import type { AggregatorSwapDto, SwapVenue } from '@xoxno/types';
+import { xdr } from '@stellar/stellar-sdk';
+/**
+ * Inlined copy of `SWAP_VENUES` from `@xoxno/types` so the SDK can validate a
+ * runtime-supplied venue without forcing the (NestJS-coupled) `@xoxno/types`
+ * module to load at runtime. Kept in lockstep with the upstream constant; any
+ * new on-chain venue must be added in both places + the contract's `SwapVenue`
+ * enum.
+ */
+export declare const STELLAR_SWAP_VENUES: readonly ["Soroswap", "Aquarius", "Phoenix", "NativeAmm", "StaticBridge"];
+export type StellarSwapStepsInput = AggregatorSwapDto;
+export declare const addr: (a: string) => xdr.ScVal;
+export declare const i128: (s: string) => xdr.ScVal;
+export declare const u32: (n: number) => xdr.ScVal;
+export declare const u64: (n: number | string) => xdr.ScVal;
+export declare const bool: (b: boolean) => xdr.ScVal;
+export declare const str: (s: string) => xdr.ScVal;
+export declare const sym: (s: string) => xdr.ScVal;
+export declare const voidVal: () => xdr.ScVal;
+export declare const vec: (items: xdr.ScVal[]) => xdr.ScVal;
+export declare const bytes: (hex: string) => xdr.ScVal;
+/**
+ * Encode a Soroban `BytesN<N>` (default 32) — a fixed-length byte array such as
+ * a WASM hash. Validates the decoded length so a malformed hash fails at the
+ * SDK boundary, not deep inside the host.
+ */
+export declare const bytesN: (hex: string, length?: number) => xdr.ScVal;
+/**
+ * Encode a Soroban `Option<T>`: `None` is `scvVoid`, `Some(x)` is the bare
+ * encoded `x` (Soroban does not wrap `Some`). NOT for the contract's custom
+ * `OracleSourceConfigInputOption` enum, which is a tagged union — see
+ * `encodeOracleSourceConfigInputOption` in `admin.ts`.
+ */
+export declare const option: <T>(value: T | undefined | null, encode: (v: T) => xdr.ScVal) => xdr.ScVal;
+/**
+ * Encode a single Soroban tuple `(Address, i128)` as a 2-element `scvVec`.
+ */
+export declare const tupleAddrAmount: (token: string, amount: string) => xdr.ScVal;
+/**
+ * Encode `Vec<(Address, i128)>` — a Soroban tuple-vec of (asset, amount).
+ * Each tuple is a 2-element `scvVec`.
+ */
+export declare const tupleAddrAmountVec: (entries: Array<{
+    token: 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.
+ */
+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;
+/**
+ * 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.
+ */
+export declare const encodeAggregatorSwap: (swap: StellarSwapStepsInput) => xdr.ScVal;
+/**
+ * Validate the untyped `steps` field from a Wave 0 DTO and narrow it to
+ * `AggregatorSwapDto`. Throws a clear error if the caller passed the wrong
+ * shape so the failure surfaces at the SDK boundary, not deep inside the
+ * Soroban host on-chain.
+ */
+export declare const asStellarSwapSteps: (steps: unknown) => StellarSwapStepsInput;
+/**
+ * Validate the untyped `data` field on FlashLoanArgs and narrow it to
+ * Buffer / hex string for Soroban `Bytes` encoding.
+ */
+export declare const asStellarBytes: (data: unknown) => xdr.ScVal;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@xoxno/sdk-js",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "The SDK to interact with the XOXNO Protocol!",
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs.js"
     }
   },
   "types": "./dist/index.d.ts",
@@ -20,7 +20,7 @@
   "scripts": {
     "test": "jest",
     "build:sdk": "npx bun run src/sdk/parseSwagger.ts && npx oxlint src/sdk/swagger.ts --fix && npx bun run md/extract.ts",
-    "build:types": "tsc --emitDeclarationOnly",
+    "build:types": "tsc --emitDeclarationOnly && dts-bundle-generator --no-check --external-imports @xoxno/types @stellar/stellar-sdk @nestjs/common @nestjs/swagger -o dist/index.d.ts src/index.ts",
     "build:esm": "webpack --config webpack-esm.config.mjs",
     "build:cjs": "webpack --config webpack-cjs.config.mjs",
     "build": "npm run build:sdk && npm run build:types && npm run build:esm && npm run build:cjs",
@@ -63,6 +63,8 @@
     "@commitlint/cli": "^20.4.1",
     "@commitlint/config-conventional": "^20.4.1",
     "@multiversx/sdk-extension-provider": "^5.1.2",
+    "@nestjs/common": "^11.1.24",
+    "@nestjs/swagger": "^11.4.4",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@swc/cli": "^0.8.0",
@@ -74,6 +76,7 @@
     "commitizen": "^4.2.4",
     "cookies-next": "^6.1.1",
     "cz-conventional-changelog": "^3.3.0",
+    "dts-bundle-generator": "^9.5.1",
     "fork-ts-checker-webpack-plugin": "^9.1.0",
     "husky": "^9.1.7",
     "jest": "^30.2.0",
@@ -94,6 +97,6 @@
     "@multiversx/sdk-core": "^15.3.2",
     "@multiversx/sdk-network-providers": "^2.9.3",
     "@stellar/stellar-sdk": "^15.0.1",
-    "@xoxno/types": "^1.0.398"
+    "@xoxno/types": "^1.0.404"
   }
 }