@xoxno/sdk-js 1.0.224 → 1.0.226

package/dist/esm/sdk/stellar/governance.js

@@ -0,0 +1,403 @@
+/**
+ * Stellar lending governance (timelock) transaction builders. Each builder
+ * returns an unsigned `BuiltStellarTx` XDR targeting the governance contract
+ * selected explicitly by `opts.governanceAddress`.
+ *
+ * Flow:
+ *   - An admin holding the PROPOSER role calls the single `propose(proposer,
+ *     op: AdminOperation, salt)` entrypoint. `proposer = opts.caller`; `op` is
+ *     the serialized `AdminOperation` enum identifying the target setter and its
+ *     args; `salt: BytesN<32>` is trailing. Validation runs at propose time and
+ *     the call returns the operation id (`BytesN<32>`).
+ *   - After the timelock delay, ANYONE executes. Controller-targeted ops go
+ *     through the generic `execute(executor, target, function, args,
+ *     predecessor, salt)`; governance-self ops go through `execute_self(executor,
+ *     op: AdminOperation, salt)`. Open execution passes `executor = None`
+ *     (Soroban `Option::None`, encoded as `scvVoid`).
+ *   - `predecessor` is ALWAYS the 32-zero-byte `BytesN<32>` in this system.
+ *
+ * The on-chain scheduled `Operation` (target, function, args) is byte-identical
+ * to the pre-enum typed proposers, so the operation id, the generic `execute`
+ * path, and event indexing are unchanged. The `AdminOperation` enum only changes
+ * the `propose` / `execute_self` call encoding, which these builders own.
+ *
+ * Builders are RPC-free and deterministic (synthetic `Account(caller,
+ * sourceSequence)`), exactly like the lending / admin builders. The returned
+ * XDR still needs `rpc.Server.prepareTransaction` before signing.
+ */ import { Buffer } from "buffer";
+import { Account, BASE_FEE, Contract, TransactionBuilder, xdr } from "@stellar/stellar-sdk";
+import { encodeAssetOracle, encodeInterestRateModel, encodeMarketParamsRaw, encodePositionLimits, encodePriceKey } from "./admin.js";
+import { STELLAR_NETWORK_PASSPHRASE } from "./contracts.js";
+import { addr, bool, bytesN, hubAsset, i128, option, scStruct, sym, u32, vec, voidVal } from "./scval-encode.js";
+/** The 32-zero-byte `BytesN<32>` predecessor used for every op in this system. */ export const STELLAR_GOVERNANCE_ZERO_PREDECESSOR = '00'.repeat(32);
+/**
+ * Coerce a 32-byte hex string / Buffer / Uint8Array salt into a Soroban
+ * `BytesN<32>` ScVal. Validates the length at the SDK boundary.
+ */ const saltScVal = (salt)=>{
+    if (typeof salt === 'string') return bytesN(salt);
+    const buf = Buffer.from(salt);
+    if (buf.length !== 32) {
+        throw new Error(`Stellar governance builder: expected a 32-byte salt (got ${buf.length} bytes)`);
+    }
+    return xdr.ScVal.scvBytes(buf);
+};
+// -----------------------------------------------------------------------------
+// AdminOperation enum encoding
+// -----------------------------------------------------------------------------
+/**
+ * Encode an `AdminOperation` enum value. At the XDR level a Soroban enum value
+ * is `scvVec([scvSymbol(VariantName), ...payload])`: a unit variant carries only
+ * the symbol, a single/tuple variant appends its fields in declaration order,
+ * and a struct-carrying variant appends the single `scStruct(..)` payload. The
+ * `VariantName` MUST match the Rust `AdminOperation` variant identifier exactly.
+ */ const adminOp = (variant, ...payload)=>vec([
+        sym(variant),
+        ...payload
+    ]);
+// Argument-struct encoders. The `scStruct` keys MUST be the Rust struct field
+// names (snake_case); `scStruct` sorts them lexicographically into the `scvMap`
+// layout the contract decodes. Builder arg interfaces stay camelCase.
+const encodeCreatePoolArgs = (a)=>scStruct({
+        asset: addr(a.asset),
+        hub_id: u32(a.hubId),
+        params: encodeMarketParamsRaw(a.params)
+    });
+const encodeUpgradePoolParamsArgs = (a)=>scStruct({
+        hub_asset: hubAsset(a.hubId, a.asset),
+        params: encodeInterestRateModel(a.params)
+    });
+const encodeTransferOwnershipArgs = (a)=>scStruct({
+        new_owner: addr(a.newOwner),
+        live_until_ledger: u32(a.liveUntilLedger)
+    });
+const encodeConfigureAssetOracleArgs = (a)=>scStruct({
+        key: encodePriceKey(a.key),
+        oracle: encodeAssetOracle(a.oracle)
+    });
+// Keys MUST be exactly the Rust `SpokeAssetArgs` fields — a Soroban struct
+// decodes from an ScMap whose key set matches the declaration exactly, so a
+// stale extra key fails the whole proposal at decode time.
+const encodeSpokeAssetArgs = (a)=>scStruct({
+        asset: addr(a.asset),
+        bonus: u32(a.bonus),
+        borrow_cap: i128(a.borrowCap),
+        can_borrow: bool(a.canBorrow),
+        can_collateral: bool(a.canCollateral),
+        frozen: bool(a.frozen),
+        hub_id: u32(a.hubId),
+        paused: bool(a.paused),
+        liquidation_fees: u32(a.liquidationFees),
+        ltv: u32(a.ltv),
+        no_seize: bool(a.noSeize),
+        spoke_id: u32(a.spokeId),
+        supply_cap: i128(a.supplyCap),
+        threshold: u32(a.threshold)
+    });
+const encodeRemoveAssetFromSpokeArgs = (a)=>scStruct({
+        hub_asset: hubAsset(a.hubId, a.asset),
+        spoke_id: u32(a.spokeId)
+    });
+const encodeSpokeLiquidationCurveArgs = (a)=>scStruct({
+        hf_for_max_bonus_wad: i128(a.hfForMaxBonusWad),
+        liquidation_bonus_factor_bps: u32(a.liquidationBonusFactorBps),
+        spoke_id: u32(a.spokeId),
+        target_hf_wad: i128(a.targetHfWad)
+    });
+const encodeEditToleranceArgs = (a)=>scStruct({
+        key: encodePriceKey(a.key),
+        tolerance: u32(a.tolerance)
+    });
+const encodeRoleArgs = (a)=>scStruct({
+        account: addr(a.account),
+        role: sym(a.role)
+    });
+// -----------------------------------------------------------------------------
+// Governance transaction assembly
+// -----------------------------------------------------------------------------
+/**
+ * Assemble an unsigned XDR invoking a single method on the GOVERNANCE contract.
+ * Mirrors `buildTx` (lending.ts) but resolves `opts.governanceAddress` instead
+ * of the controller address. RPC-free + deterministic.
+ */ function buildGovernanceTx(opts, method, params) {
+    if (!opts.governanceAddress) {
+        throw new Error('Stellar governanceAddress is required');
+    }
+    const contract = new Contract(opts.governanceAddress);
+    const source = new Account(opts.caller, opts.sourceSequence);
+    const tx = new TransactionBuilder(source, {
+        fee: opts.fee ?? BASE_FEE,
+        networkPassphrase: STELLAR_NETWORK_PASSPHRASE[opts.network]
+    }).addOperation(contract.call(method, ...params)).setTimeout(opts.timeoutSeconds ?? 300).build();
+    return {
+        xdr: tx.toXDR()
+    };
+}
+/**
+ * Build a `propose(proposer, op, salt)` tx: `proposer = opts.caller`, then the
+ * `AdminOperation`, then `salt`. The caller must hold PROPOSER and sign the tx.
+ */ const buildPropose = (opts, op, salt)=>buildGovernanceTx(opts, 'propose', [
+        addr(opts.caller),
+        op,
+        saltScVal(salt)
+    ]);
+/**
+ * Build an `execute_self(executor, op, salt)` (governance-self) tx: `executor =
+ * None`, then the `AdminOperation`, then `salt`. Open execution — any account
+ * may sign. Self-target ops cannot use the generic `execute` (the timelock
+ * rejects `target == governance` to avoid self-reentry).
+ */ const buildExecuteSelf = (opts, op, salt)=>buildGovernanceTx(opts, 'execute_self', [
+        voidVal(),
+        op,
+        saltScVal(salt)
+    ]);
+// -----------------------------------------------------------------------------
+// CONTROLLER-targeted proposers — proposer + AdminOperation + salt
+// -----------------------------------------------------------------------------
+/** propose(SetSwapAggregator(addr)) */ export function buildStellarProposeSetSwapAggregatorTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetSwapAggregator', addr(args.aggregator)), salt);
+}
+/** propose(SetPriceAggregator(addr)) — Sensitive-tier self-op. */ export function buildStellarProposeSetPriceAggregatorTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetPriceAggregator', addr(args.aggregator)), salt);
+}
+/** propose(SetAccumulator(addr)) */ export function buildStellarProposeSetAccumulatorTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetAccumulator', addr(args.accumulator)), salt);
+}
+/** propose(SetPositionLimits(limits)) */ export function buildStellarProposeSetPositionLimitsTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetPositionLimits', encodePositionLimits(args)), salt);
+}
+/** propose(CreateHub) */ export function buildStellarProposeCreateHubTx(opts, salt) {
+    return buildPropose(opts, adminOp('CreateHub'), salt);
+}
+/** propose(AddSpoke) */ export function buildStellarProposeAddSpokeTx(opts, salt) {
+    return buildPropose(opts, adminOp('AddSpoke'), salt);
+}
+/** propose(RemoveSpoke(spoke_id)) */ export function buildStellarProposeRemoveSpokeTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('RemoveSpoke', u32(args.spokeId)), salt);
+}
+/** propose(AddAssetToSpoke(SpokeAssetArgs)) */ export function buildStellarProposeAddAssetToSpokeTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('AddAssetToSpoke', encodeSpokeAssetArgs(args)), salt);
+}
+/** propose(EditAssetInSpoke(SpokeAssetArgs)) */ export function buildStellarProposeEditAssetInSpokeTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('EditAssetInSpoke', encodeSpokeAssetArgs(args)), salt);
+}
+/** propose(RemoveAssetFromSpoke(RemoveAssetFromSpokeArgs)) */ export function buildStellarProposeRemoveAssetFromSpokeTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('RemoveAssetFromSpoke', encodeRemoveAssetFromSpokeArgs(args)), salt);
+}
+/** propose(SetSpokeLiquidationCurve(SpokeLiquidationCurveArgs)) */ export function buildStellarProposeSetSpokeLiquidationCurveTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetSpokeLiquidationCurve', encodeSpokeLiquidationCurveArgs(args)), salt);
+}
+/** propose(SetPositionManager(manager, is_active)) — tuple variant. */ export function buildStellarProposeSetPositionManagerTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetPositionManager', addr(args.manager), bool(args.isActive)), salt);
+}
+/** propose(SetMinBorrowCollateralUsd(floor_wad)) */ export function buildStellarProposeSetMinBorrowCollatTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('SetMinBorrowCollateralUsd', i128(args.floorWad)), salt);
+}
+/** propose(ApproveToken(token)) */ export function buildStellarProposeApproveTokenTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('ApproveToken', addr(args.token)), salt);
+}
+/** propose(RevokeToken(token)) */ export function buildStellarProposeRevokeTokenTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('RevokeToken', addr(args.token)), salt);
+}
+/** propose(ApproveBlendPool(pool)) */ export function buildStellarProposeApproveBlendPoolTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('ApproveBlendPool', addr(args.pool)), salt);
+}
+/** propose(RevokeBlendPool(pool)) */ export function buildStellarProposeRevokeBlendPoolTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('RevokeBlendPool', addr(args.pool)), salt);
+}
+/** propose(CreateLiquidityPool(CreatePoolArgs)) */ export function buildStellarProposeCreateLiquidityPoolTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('CreateLiquidityPool', encodeCreatePoolArgs(args)), salt);
+}
+/** propose(UpgradeLiquidityPoolParams(UpgradePoolParamsArgs)) */ export function buildStellarProposeUpgradePoolParamsTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('UpgradeLiquidityPoolParams', encodeUpgradePoolParamsArgs(args)), salt);
+}
+/** propose(DeployPool(hash)) */ export function buildStellarProposeDeployPoolTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('DeployPool', bytesN(args.wasmHash)), salt);
+}
+/** propose(UpgradePool(hash)) */ export function buildStellarProposeUpgradePoolTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('UpgradePool', bytesN(args.wasmHash)), salt);
+}
+/** propose(UpgradeController(hash)) */ export function buildStellarProposeUpgradeControllerTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('UpgradeController', bytesN(args.wasmHash)), salt);
+}
+/** propose(MigrateController(new_version)) */ export function buildStellarProposeMigrateControllerTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('MigrateController', u32(args.newVersion)), salt);
+}
+/** propose(TransferCtrlOwnership(TransferOwnershipArgs)) */ export function buildStellarProposeTransferCtrlOwnershipTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('TransferCtrlOwnership', encodeTransferOwnershipArgs(args)), salt);
+}
+/**
+ * propose(ConfigureAssetOracle(ConfigureAssetOracleArgs))
+ *
+ * Pass PriceKey + AssetOracle input; governance resolves asset_decimals for
+ * Token keys at propose time.
+ */ export function buildStellarProposeConfigureAssetOracleTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('ConfigureAssetOracle', encodeConfigureAssetOracleArgs(args)), salt);
+}
+/** propose(EditOracleTolerance(EditToleranceArgs)) */ export function buildStellarProposeEditOracleToleranceTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('EditOracleTolerance', encodeEditToleranceArgs(args)), salt);
+}
+// -----------------------------------------------------------------------------
+// GOVERNANCE-self proposers — proposer + AdminOperation + salt
+// -----------------------------------------------------------------------------
+/** propose(UpgradeGov(hash)) */ export function buildStellarProposeGovernanceUpgradeTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('UpgradeGov', bytesN(args.wasmHash)), salt);
+}
+/** propose(UpdateGovDelay(new_delay)) */ export function buildStellarProposeUpdateDelayTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('UpdateGovDelay', u32(args.newDelay)), salt);
+}
+/** propose(GrantGovRole(RoleArgs)) */ export function buildStellarProposeGrantGovernanceRoleTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('GrantGovRole', encodeRoleArgs(args)), salt);
+}
+/** propose(RevokeGovRole(RoleArgs)) */ export function buildStellarProposeRevokeGovernanceRoleTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('RevokeGovRole', encodeRoleArgs(args)), salt);
+}
+/** propose(TransferGovOwnership(TransferOwnershipArgs)) */ export function buildStellarProposeTransferGovOwnTx(opts, args, salt) {
+    return buildPropose(opts, adminOp('TransferGovOwnership', encodeTransferOwnershipArgs(args)), salt);
+}
+/**
+ * Generic `execute(executor, target, function, args, predecessor, salt)` for a
+ * controller-targeted op. `executor = None` (open execution), `target` is the
+ * controller `Address`, `function` is a `Symbol`, `args` is the `Vec<Val>`
+ * reconstructed from `argsXdr`, `predecessor` defaults to 32 zero bytes.
+ *
+ * Unchanged by the AdminOperation refactor: the scheduled `Operation` is
+ * byte-identical, so callers reconstruct `(target, function, argsXdr)` from the
+ * indexed proposal exactly as before.
+ */ export function buildStellarGovernanceExecuteTx(opts, args) {
+    const callArgs = vec(args.argsXdr.map((s)=>xdr.ScVal.fromXDR(s, 'base64')));
+    const predecessor = saltScVal(args.predecessor ?? STELLAR_GOVERNANCE_ZERO_PREDECESSOR);
+    return buildGovernanceTx(opts, 'execute', [
+        voidVal(),
+        addr(args.target),
+        sym(args.functionName),
+        callArgs,
+        predecessor,
+        saltScVal(args.salt)
+    ]);
+}
+/** execute_self(executor=None, UpgradeGov(hash), salt) */ export function buildStellarGovernanceExecuteGovernanceUpgradeTx(opts, args, salt) {
+    return buildExecuteSelf(opts, adminOp('UpgradeGov', bytesN(args.wasmHash)), salt);
+}
+/** execute_self(executor=None, UpdateGovDelay(new_delay), salt) */ export function buildStellarGovernanceExecuteUpdateDelayTx(opts, args, salt) {
+    return buildExecuteSelf(opts, adminOp('UpdateGovDelay', u32(args.newDelay)), salt);
+}
+/** execute_self(executor=None, GrantGovRole(RoleArgs), salt) */ export function buildStellarGovernanceExecuteGrantGovernanceRoleTx(opts, args, salt) {
+    return buildExecuteSelf(opts, adminOp('GrantGovRole', encodeRoleArgs(args)), salt);
+}
+/** execute_self(executor=None, RevokeGovRole(RoleArgs), salt) */ export function buildStellarGovernanceExecuteRevokeGovernanceRoleTx(opts, args, salt) {
+    return buildExecuteSelf(opts, adminOp('RevokeGovRole', encodeRoleArgs(args)), salt);
+}
+/** execute_self(executor=None, TransferGovOwnership(TransferOwnershipArgs), salt) */ export function buildStellarGovernanceExecuteTransferGovOwnTx(opts, args, salt) {
+    return buildExecuteSelf(opts, adminOp('TransferGovOwnership', encodeTransferOwnershipArgs(args)), salt);
+}
+const addressVec = (addresses)=>vec(addresses.map(addr));
+/**
+ * propose_canceller_reset(new_cancellers, salt) — owner-only, non-vetoable
+ * council reset scheduled at the Recovery delay; direct entrypoint, not
+ * `AdminOperation`. `#[only_owner]` takes no `caller` param — the tx source
+ * (`opts.caller`) must be the governance owner and sign. Returns the
+ * operation id.
+ */ export function buildStellarProposeCancellerResetTx(opts, args, salt) {
+    return buildGovernanceTx(opts, 'propose_canceller_reset', [
+        addressVec(args.newCancellers),
+        saltScVal(salt)
+    ]);
+}
+/**
+ * execute_canceller_reset(executor, new_cancellers, salt) — executes a
+ * matured council reset; direct entrypoint, not `execute_self` /
+ * `AdminOperation`. `executor` omitted leaves execution open to any account;
+ * `newCancellers` and `salt` MUST match the values passed to
+ * `buildStellarProposeCancellerResetTx`.
+ */ export function buildStellarExecuteCancellerResetTx(opts, args, salt) {
+    return buildGovernanceTx(opts, 'execute_canceller_reset', [
+        option(args.executor, addr),
+        addressVec(args.newCancellers),
+        saltScVal(salt)
+    ]);
+}
+/**
+ * set_spoke_asset_flags(caller, spoke_id, hub_asset, paused, frozen, no_seize)
+ * — GUARDIAN-gated, immediate. Flags-only per-listing incident brake: no risk
+ * params or caps travel with it. `caller = opts.caller` must hold GUARDIAN and
+ * sign.
+ *
+ * All three flags are one-way ratchets on this path — the guardian may only
+ * set them true. Clearing any of them requires the timelocked
+ * `EditAssetInSpoke` proposal.
+ */ export function buildStellarGovernanceSetSpokeAssetFlagsImmediateTx(opts, args) {
+    return buildGovernanceTx(opts, 'set_spoke_asset_flags', [
+        addr(opts.caller),
+        u32(args.spokeId),
+        hubAsset(args.hubId, args.asset),
+        bool(args.paused),
+        bool(args.frozen),
+        bool(args.noSeize)
+    ]);
+}
+/**
+ * set_oracle_sanity_bounds(caller, asset, min_wad, max_wad) — ORACLE-gated,
+ * immediate. Moves only the sanity band; the controller requires the new band
+ * to contain the current live price AND overlap the previous band (bands walk,
+ * never teleport). Reverts: InvalidSanityBounds (malformed or disjoint from
+ * the old band), SanityBoundViolated (live price outside the new band),
+ * PriceFeedStale (feed cannot prove containment). `caller = opts.caller` must
+ * hold ORACLE and sign.
+ */ export function buildStellarGovernanceSetOracleSanityBoundsImmediateTx(opts, args) {
+    return buildGovernanceTx(opts, 'set_oracle_sanity_bounds', [
+        addr(opts.caller),
+        addr(args.asset),
+        i128(args.minPriceWad),
+        i128(args.maxPriceWad)
+    ]);
+}
+/**
+ * create_hub(caller) — GUARDIAN-gated, immediate; returns the new hub id.
+ * The registry entry is inert until assets are listed through the timelocked
+ * path. Distinct from `buildStellarProposeCreateHubTx` (timelock).
+ */ export function buildStellarGovernanceCreateHubImmediateTx(opts) {
+    return buildGovernanceTx(opts, 'create_hub', [
+        addr(opts.caller)
+    ]);
+}
+/**
+ * add_spoke(caller) — GUARDIAN-gated, immediate; returns the new spoke id.
+ * Listings on it still ride the timelock. Distinct from
+ * `buildStellarProposeAddSpokeTx` (timelock).
+ */ export function buildStellarGovernanceAddSpokeImmediateTx(opts) {
+    return buildGovernanceTx(opts, 'add_spoke', [
+        addr(opts.caller)
+    ]);
+}
+/**
+ * revoke_role_immediate(account, role) — owner-gated emergency
+ * de-authorization; accepts only the immediate incident roles GUARDIAN and
+ * ORACLE (`InvalidRole` otherwise). Grants and PROPOSER/EXECUTOR/CANCELLER
+ * revocations stay timelocked. The tx source (`opts.caller`) must be the
+ * governance owner.
+ */ export function buildStellarGovernanceRevokeRoleImmediateTx(opts, args) {
+    return buildGovernanceTx(opts, 'revoke_role_immediate', [
+        addr(args.account),
+        sym(args.role)
+    ]);
+}
+/**
+ * pause(caller) — GUARDIAN-gated, immediate protocol-wide brake. Forwards to
+ * the controller's `pause`, halting supply/borrow/strategy entrypoints across
+ * every market (exits and liquidation stay open). Halting is fail-safe, so the
+ * fast incident key acts without the owner online. `caller = opts.caller` must
+ * hold GUARDIAN and sign. Distinct from the controller-targeted
+ * `buildStellarPauseTx`, which an EOA cannot call because the controller's
+ * owner is the governance contract.
+ */ export function buildStellarGovernancePauseTx(opts) {
+    return buildGovernanceTx(opts, 'pause', [
+        addr(opts.caller)
+    ]);
+}
+/**
+ * propose(Unpause) — resuming the controller is risk-loosening, so unlike the
+ * GUARDIAN-immediate `pause` it rides the timelock as a Standard-delay
+ * governance proposal. `proposer = opts.caller` must hold PROPOSER and sign.
+ */ export function buildStellarProposeUnpauseTx(opts, salt) {
+    return buildPropose(opts, adminOp('Unpause'), salt);
+}

package/dist/esm/sdk/stellar/index.js

@@ -0,0 +1,26 @@
+/**
+ * Typed Stellar lending reads and unsigned Soroban transaction builders.
+ * Start with {@link stellarLendingRead}, then {@link buildStellarSupplyTx}
+ * and {@link prepareStellarBuiltTx}. The host wallet signs prepared XDR.
+ * @module Stellar lending
+ */ export { XOXNOClient } from "../../utils/api.js";
+export * from "./contracts.js";
+export * from "./lending.js";
+export * from "./lending-read.js";
+export * from "./read/index.js";
+export * from "./admin.js";
+export * from "./governance.js";
+export * from "./events/index.js";
+export * from "./quote.js";
+export * from "./swap.js";
+export * from "./swap-history.js";
+export * from "./route-verify.js";
+export * from "./auth-policy.js";
+export * from "./prepare.js";
+export * from "./position-mode.js";
+export * from "./repay-swap.js";
+export * from "./cctp.js";
+export * from "./math/index.js";
+// Soroban error mapper; re-export at the stellar subpath so consumers can
+// import from '@xoxno/sdk-js/stellar-lending' when decoding contract errors.
+export { mapSorobanError } from "../../utils/soroban-errors.js";

package/dist/esm/sdk/stellar/lending-api-types.js

@@ -0,0 +1,3 @@
+/** @module Stellar lending API types
+ * Generated from src/sdk/swagger.json; do not edit by hand.
+ */ export { };

package/dist/esm/sdk/stellar/lending-read-types.js

@@ -0,0 +1 @@
+/** Public reader aliases. All response fields come from the generated API contract. */ export * from "./lending-api-types.js";