@xoxno/sdk-js 1.0.117 → 1.0.119

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

@@ -1,14 +1,13 @@
 /**
- * Snapshot + structural tests for the Stellar lending ADMIN / CONFIG / KEEPER /
- * ACCESS transaction builders.
+ * 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.
+ * Beyond the function-name / arg-count / determinism / snapshot guards, 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. 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

@@ -1,11 +1,8 @@
 /**
- * Decoder tests locked against REAL captured event XDR.
+ * Decoder tests locked against 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.
+ * `fixtures/lending-events.json` holds every controller `#[contractevent]`'s
+ * topics + `data` serialized to base64 XDR, exactly as Soroban RPC `getEvents`
+ * delivers them.
  */
 export {};

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

@@ -1,10 +1,4 @@
 /**
- * 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.
+ * Tests for the Stellar lending activity-id primitives, locking their outputs.
  */
 export {};

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

@@ -1,10 +1,6 @@
 /**
- * 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.
+ * Stellar lending admin / config / keeper / access transaction builders. Each
+ * builder returns an unsigned `BuiltStellarTx` XDR.
  *
  * Auth model:
  *   - `#[only_owner]` methods take no `caller` param — the tx source
@@ -12,10 +8,6 @@
  *   - `#[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';

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

@@ -1,25 +1,16 @@
 /**
- * Decoders for the 21 XOXNO Stellar lending controller `#[contractevent]`s.
+ * Decoders for the 21 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).
+ * The public API takes base64-XDR strings (`decodeStellarLendingEvent(topicsB64,
+ * dataB64)`) and parses them with this SDK's bundled `@stellar/stellar-sdk`, so
+ * no live `xdr.ScVal` crosses the consumer boundary. 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).
+ * Each contractevent `data` serializes as an `ScMap` keyed by field name, 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.
  */
 import type { StellarLendingDecodedEvent } from '@xoxno/types';
 /**

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

@@ -1,16 +1,10 @@
 /**
- * Stellar lending activity-id derivation — the single owner of the inputs that
- * compose `NftActivityDoc.id` (`${txHash}-${eventIdentifier}-${eventOrder}`).
+ * Stellar lending activity-id derivation: 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.
+ * The activity-type string values mirror `@xoxno/types` `XoxnoLendingActivity`,
+ * inlined rather than imported since `@xoxno/types` does not re-export its enums
+ * on its top-level type surface.
  */
 /** Synthetic NFT collection ticker for Stellar lending accounts. */
 export declare const XOXNO_LENDING_STELLAR_TICKER = "XLENDXLM-a7c9f3";

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

@@ -1,40 +1,19 @@
 /**
- * Stellar Soroban lending transaction builders (Wave 1B).
+ * Stellar lending user-operation transaction builders.
  *
- * Each builder takes a Wave 0 `*Args` DTO from @xoxno/types plus a shared
- * `StellarBuilderOptions` ({ network, caller, sourceSequence, ... }) and
- * returns an unsigned transaction XDR string ready for wallet signing
- * (Freighter / LOBSTR / xBull / WalletConnect via StellarWalletsKit).
+ * Each builder takes an `*Args` DTO from `@xoxno/types` plus a shared
+ * `StellarBuilderOptions` ({ network, caller, sourceSequence, ... }) and returns
+ * an unsigned transaction XDR string ready for wallet signing.
  *
- * Mirrors the Stellar controller entry points in
- * rs-lending/stellar/controller/src/lib.rs:
- *
- *   supply(caller, account_id: u64, e_mode_category: u32, assets: Vec<(Address, i128)>) -> u64
- *   borrow(caller, account_id: u64, borrows: Vec<(Address, i128)>)
- *   withdraw(caller, account_id: u64, withdrawals: Vec<(Address, i128)>)
- *   repay(caller, account_id: u64, payments: Vec<(Address, i128)>)
- *   liquidate(liquidator, account_id: u64, debt_payments: Vec<(Address, i128)>)
- *   flash_loan(caller, asset, amount: i128, receiver, data: Bytes)
- *   multiply(caller, account_id, e_mode_category, collateral_token,
- *            debt_to_flash_loan: i128, debt_token, mode: u32, steps: SwapSteps) -> u64
- *   swap_debt(caller, account_id, existing_debt_token, new_debt_amount: i128,
- *             new_debt_token, steps: SwapSteps)
- *   swap_collateral(caller, account_id, current_collateral, from_amount: i128,
- *                   new_collateral, steps: SwapSteps)
- *   repay_debt_with_collateral(caller, account_id, collateral_token,
- *                              collateral_amount: i128, debt_token,
- *                              steps: SwapSteps, close_position: bool)
- *
- * i128 values cross the boundary as decimal strings and are encoded via
- * `new ScInt(str).toI128()`. addresses (Stellar `G...` accounts and Soroban
+ * i128 values cross the boundary as decimal strings, encoded via
+ * `new ScInt(str).toI128()`. Addresses (Stellar `G...` accounts and Soroban
  * `C...` contracts) are encoded via `new Address(str).toScVal()`.
  *
- * These builders are RPC-free on purpose: they accept a caller-supplied
- * `sourceSequence` so the returned XDR is deterministic and snapshot-testable.
- * The UI hook layer (Wave 1C) is responsible for fetching the current sequence
- * via `rpc.Server.getAccount(caller)` and calling `rpc.Server.prepareTransaction`
- * (which handles simulation + Soroban footprint/auth/resource fee) before
- * handing the XDR to the wallet to sign.
+ * Builders are RPC-free: they accept a caller-supplied `sourceSequence` so the
+ * returned XDR is deterministic and snapshot-testable. The caller fetches the
+ * current sequence via `rpc.Server.getAccount(caller)` and runs
+ * `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 { xdr } from '@stellar/stellar-sdk';
@@ -70,36 +49,12 @@ export interface BuiltStellarTx {
 }
 /**
  * Input shape for the Stellar-specific `swap` payload carried on
- * `MultiplyArgs.steps`, `SwapDebtArgs.steps`, `SwapCollateralArgs.steps`,
+ * `MultiplyArgs.steps`, `SwapDebtArgs.steps`, `SwapCollateralArgs.steps`, and
  * `RepayDebtWithCollateralArgs.steps`.
  *
- * @xoxno/types declares `steps: unknown` on the Wave 0 DTOs so every chain
- * owns its own encoding. On Stellar, callers MUST pass an
- * `AggregatorSwapDto` which is serialised into the Soroban
- * `AggregatorSwap` struct from `rs-lending-xlm common/src/types.rs`:
- *
- *   pub struct SwapHop {
- *       pub fee_bps: u32,
- *       pub pool: Address,
- *       pub token_in: Address,
- *       pub token_out: Address,
- *       pub venue: SwapVenue,   // tag-only enum
- *   }
- *   pub struct SwapPath {
- *       pub amount_in: i128,
- *       pub hops: Vec<SwapHop>,
- *       pub min_amount_out: i128,
- *   }
- *   pub struct AggregatorSwap {  // controller payload
- *       pub paths: Vec<SwapPath>,
- *       pub total_min_out: i128,
- *   }
- *
- * The controller wraps `AggregatorSwap` in `BatchSwap` (filling
- * `sender = current_contract_address`) before forwarding to the router.
- *
- * Re-exported from this module so consumers can `import { StellarSwapStepsInput }`
- * and get the canonical typed shape without reaching into `@xoxno/types`.
+ * `@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.
  */
 export type StellarSwapStepsInput = AggregatorSwapDto;
 export type StellarSwapHopInput = SwapHopDto;

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

@@ -1,26 +1,15 @@
 /**
- * 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.
+ * Soroban `ScVal` encoding primitives for the Stellar lending builders.
  *
  * 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.
+ * `new Address(str).toScVal()`.
  */
 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.
+ * On-chain swap venues, validated at runtime for a caller-supplied venue.
+ * Mirrors `SWAP_VENUES` from `@xoxno/types` and the contract's `SwapVenue` enum.
  */
 export declare const STELLAR_SWAP_VENUES: readonly ["Soroswap", "Aquarius", "Phoenix", "NativeAmm", "StaticBridge"];
 export type StellarSwapStepsInput = AggregatorSwapDto;
@@ -78,10 +67,9 @@ export declare const encodeSwapVenue: (venue: SwapVenue) => xdr.ScVal;
  */
 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.
+ * Validate the untyped `steps` field and narrow it to `AggregatorSwapDto`.
+ * 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;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xoxno/sdk-js",
-  "version": "1.0.117",
+  "version": "1.0.119",
   "description": "The SDK to interact with the XOXNO Protocol!",
   "type": "module",
   "exports": {
@@ -104,6 +104,6 @@
     "@multiversx/sdk-core": "^15.3.2",
     "@multiversx/sdk-network-providers": "^2.9.3",
     "@stellar/stellar-sdk": "^15.0.1",
-    "@xoxno/types": "^1.0.404"
+    "@xoxno/types": "^1.0.407"
   }
 }