@xoxno/sdk-js 1.0.141 → 1.0.142

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './utils/api';
+export * from './utils/regex';
+export * from './sdk';

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,4 @@
+import type { XOXNOClient } from '../utils/api';
+import type { SDK } from './types';
+export * from './stellar';
+export declare function buildSdk(client: XOXNOClient): SDK;

package/dist/cjs/sdk/parseSwagger.d.ts

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

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

@@ -0,0 +1,13 @@
+/**
+ * Snapshot + structural tests for the Stellar lending admin / config / keeper /
+ * access transaction builders.
+ *
+ * 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/cjs/sdk/stellar/__tests__/decode.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Decoder tests locked against captured event XDR.
+ *
+ * `fixtures/lending-events.json` holds the map-encoded controller
+ * `#[contractevent]`s' topics + `data` serialized to base64 XDR, exactly as
+ * Soroban RPC `getEvents` delivers them. The two vec-encoded ABI v2 topics
+ * (`position:batch_update`, `market:batch_state_update`) are constructed below
+ * with ScVal builders so the wire field order stays explicit.
+ */
+export {};

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for the Stellar lending activity-id primitives, locking their outputs.
+ */
+export {};

package/dist/cjs/sdk/stellar/__tests__/lending.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Snapshot + sanity tests for the Stellar Soroban lending transaction builders.
+ *
+ * These tests assert:
+ *   1. Every builder returns a non-empty base64 XDR.
+ *   2. XDR parses back into a valid Transaction with exactly one InvokeHostFunction
+ *      operation targeting the configured controller contract.
+ *   3. The function name encoded in the XDR matches the Stellar controller
+ *      entry point exactly (`supply`, `borrow`, `withdraw`, `repay`,
+ *      `liquidate`, `flash_loan`, `multiply`, `swap_debt`, `swap_collateral`,
+ *      `repay_debt_with_collateral`).
+ *   4. The XDR is deterministic — identical fixture inputs yield identical XDR.
+ *   5. Stable snapshots for the full XDR of every builder (regression guard
+ *      for any unintended encoding change).
+ *
+ * Builders are RPC-free — they accept a `sourceSequence` so output is
+ * fully deterministic and snapshot-testable. The UI layer is responsible
+ * for fetching the sequence and running `rpc.Server.prepareTransaction`
+ * before signing.
+ */
+export {};

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

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

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

@@ -0,0 +1,170 @@
+/**
+ * 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
+ *     (`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.
+ */
+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` — 11 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 EModeAssetArgs {
+    asset: string;
+    categoryId: number;
+    canCollateral: boolean;
+    canBorrow: boolean;
+    ltv: number;
+    threshold: number;
+    bonus: number;
+}
+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() -> u32 — #[only_owner]. Risk params are per-asset. */
+export declare function buildStellarAddEModeCategoryTx(opts: StellarBuilderOptions): 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, ltv, threshold, bonus) — #[only_owner] */
+export declare function buildStellarAddAssetToEModeCategoryTx(opts: StellarBuilderOptions, args: EModeAssetArgs): BuiltStellarTx;
+/** edit_asset_in_e_mode_category(asset, category_id, can_collateral, can_borrow, ltv, threshold, bonus) — #[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/cjs/sdk/stellar/cctp.d.ts

@@ -0,0 +1,16 @@
+import { type StellarNetwork } from './contracts';
+import type { BuiltStellarTx, StellarBuilderOptions } from './lending';
+export interface BuildStellarCctpForwardTxArgs extends StellarBuilderOptions {
+    forwarderAddress: string;
+    message: string;
+    attestation: string;
+    /** Default 10_000_000 stroops — CCTP mint_and_forward is resource-heavy. */
+    fee?: string;
+    /** Default 120 seconds. */
+    timeoutSeconds?: number;
+}
+/**
+ * Build an unsigned XDR for the Stellar CCTP forwarder `mint_and_forward`.
+ */
+export declare function buildStellarCctpForwardTx(opts: BuildStellarCctpForwardTxArgs): BuiltStellarTx;
+export type { StellarNetwork };

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

@@ -0,0 +1,70 @@
+/**
+ * Stellar Soroban contract addresses + Soroban RPC + quote-server config
+ * per network.
+ *
+ * Addresses are env-sourced so ops can rotate mainnet/testnet deployments
+ * without a code change. Defaults fall back to empty strings so a missing
+ * env surfaces as a clear "not configured" error at call time rather than
+ * silently pointing at the wrong contract.
+ */
+export type StellarNetwork = 'mainnet' | 'testnet';
+/**
+ * Stellar lending controller contract addresses per network.
+ * Env vars:
+ *   - STELLAR_LENDING_CONTROLLER_MAINNET
+ *   - STELLAR_LENDING_CONTROLLER_TESTNET
+ */
+export declare const STELLAR_LENDING_CONTROLLER: Record<StellarNetwork, string>;
+/**
+ * Stellar aggregator router contract addresses per network.
+ * Targets `execute_strategy(sender, total_in, swap_xdr)` for direct
+ * (non-lending) swaps.
+ * Env vars:
+ *   - STELLAR_AGGREGATOR_ROUTER_MAINNET
+ *   - STELLAR_AGGREGATOR_ROUTER_TESTNET
+ */
+export declare const STELLAR_AGGREGATOR_ROUTER: Record<StellarNetwork, string>;
+/**
+ * Stellar governance (timelock) contract addresses per network. Owns the
+ * controller's admin surface: PROPOSER-gated `propose_*` scheduling and the
+ * open `execute` / `execute_*` lifecycle.
+ * Env vars:
+ *   - STELLAR_GOVERNANCE_MAINNET
+ *   - STELLAR_GOVERNANCE_TESTNET
+ */
+export declare const STELLAR_GOVERNANCE: Record<StellarNetwork, string>;
+/**
+ * Default Soroban RPC URLs per network.
+ * Overridable at runtime via the `sorobanRpcUrl` option on each builder.
+ */
+export declare const STELLAR_SOROBAN_RPC_URL: Record<StellarNetwork, string>;
+/**
+ * Stellar aggregator quote-server base URLs per network. The quote server
+ * exposes `GET /api/v1/tokens` and `GET /api/v1/quote`.
+ *
+ * Env vars:
+ *   - STELLAR_QUOTE_URL_MAINNET
+ *   - STELLAR_QUOTE_URL_TESTNET
+ */
+export declare const STELLAR_QUOTE_URL: Record<StellarNetwork, string>;
+/**
+ * Stellar network passphrases (Soroban tx signing domain separator).
+ * These are fixed by the Stellar network itself and must not be overridden.
+ */
+export declare const STELLAR_NETWORK_PASSPHRASE: Record<StellarNetwork, string>;
+/**
+ * Assert a controller address is configured for the target network.
+ * Throws early with a clear message rather than building an XDR that
+ * points at `""`.
+ */
+export declare function getStellarLendingController(network: StellarNetwork): string;
+/**
+ * Assert an aggregator router address is configured for the target network.
+ * Used by `buildStellarExecuteStrategyTx` for direct user -> router swaps.
+ */
+export declare function getStellarAggregatorRouter(network: StellarNetwork): string;
+/**
+ * Assert a governance address is configured for the target network. Used by
+ * the governance `propose_*` / `execute` / `execute_*` builders.
+ */
+export declare function getStellarGovernance(network: StellarNetwork): string;

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

@@ -0,0 +1,45 @@
+/**
+ * Decoders for the Stellar lending controller `#[contractevent]`s.
+ *
+ * The controller defines 20 contractevents; this SDK decodes 19. The lone
+ * omission is `config:min_borrow_collateral` (a single global `i128` floor with
+ * no indexing/UI consumer — the governance `SetMinBorrowCollateral` proposal
+ * already surfaces the value), so `decodeStellarLendingEvent` returns `null` for
+ * it like any other unhandled topic.
+ *
+ * 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.
+ *
+ * Most 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.
+ *
+ * The two hot topics (`position:batch_update`, `market:batch_state_update`)
+ * use the vec-encoded ABI v2 instead: `data` is an `ScVec` whose field order
+ * IS the ABI, so `scValToNative` yields nested arrays decoded positionally.
+ */
+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 (19 of the controller's 20 contractevents;
+ * `config:min_borrow_collateral` is intentionally not decoded). */
+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/cjs/sdk/stellar/events/id.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Stellar lending activity-id derivation: the inputs that compose
+ * `NftActivityDoc.id` (`${txHash}-${eventIdentifier}-${eventOrder}`).
+ *
+ * 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";
+/**
+ * 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/cjs/sdk/stellar/events/index.d.ts

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

package/dist/cjs/sdk/stellar/governance.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Stellar lending governance (timelock) transaction builders. Each builder
+ * returns an unsigned `BuiltStellarTx` XDR targeting the governance contract
+ * (`opts.governanceAddress`, or env via `getStellarGovernance(network)`).
+ *
+ * Flow:
+ *   - An admin holding the PROPOSER role calls a `propose_*` method. The
+ *     leading arg is `proposer = opts.caller` (an `Address`); the remaining
+ *     args mirror the matching controller setter exactly; the trailing arg is
+ *     a `salt: BytesN<32>`. Validation runs at propose time; 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 typed `execute_*`.
+ *     Open execution passes `executor = None` (Soroban `Option::None`, encoded
+ *     as `scvVoid` — mirrors the lending `withdraw` builder's optional `to`).
+ *   - `predecessor` is ALWAYS the 32-zero-byte `BytesN<32>` in this system.
+ *
+ * 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 type { PositionLimitsDto } from '@xoxno/types';
+import { type ConfigureMarketOracleArgs, type CreateLiquidityPoolArgs, type EditAssetConfigArgs, type EditOracleToleranceArgs, type EModeAssetArgs, type RemoveEModeAssetArgs, type RoleGrantArgs, type TransferOwnershipArgs, type UpgradeLiquidityPoolParamsArgs } from './admin';
+import type { BuiltStellarTx, StellarBuilderOptions } from './lending';
+/**
+ * A `salt: BytesN<32>` for a governance proposal/execution. Accepts a 32-byte
+ * hex string (optionally `0x`-prefixed) or a 32-byte `Buffer`/`Uint8Array`.
+ */
+export type StellarGovernanceSalt = string | Buffer | Uint8Array;
+/** The 32-zero-byte `BytesN<32>` predecessor used for every op in this system. */
+export declare const STELLAR_GOVERNANCE_ZERO_PREDECESSOR: string;
+export interface RemoveEModeCategoryArgs {
+    id: number;
+}
+export interface UpgradeArgs {
+    wasmHash: string;
+}
+export interface MigrateArgs {
+    newVersion: number;
+}
+export interface UpdateDelayArgs {
+    newDelay: number;
+}
+/** propose_set_aggregator(proposer, addr: Address, salt) */
+export declare function buildStellarProposeSetAggregatorTx(opts: StellarBuilderOptions, args: {
+    aggregator: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_set_accumulator(proposer, addr: Address, salt) */
+export declare function buildStellarProposeSetAccumulatorTx(opts: StellarBuilderOptions, args: {
+    accumulator: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_set_pool_template(proposer, hash: BytesN<32>, salt) */
+export declare function buildStellarProposeSetPoolTemplateTx(opts: StellarBuilderOptions, args: {
+    wasmHash: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_edit_asset_config(proposer, asset: Address, cfg: AssetConfigRaw, salt) */
+export declare function buildStellarProposeEditAssetConfigTx(opts: StellarBuilderOptions, args: EditAssetConfigArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_set_position_limits(proposer, limits: PositionLimits, salt) */
+export declare function buildStellarProposeSetPositionLimitsTx(opts: StellarBuilderOptions, args: PositionLimitsDto, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_set_min_borrow_collat(proposer, floor_wad: i128, salt) */
+export declare function buildStellarProposeSetMinBorrowCollatTx(opts: StellarBuilderOptions, args: {
+    floorWad: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_add_e_mode_category(proposer, salt) — risk params are per-asset */
+export declare function buildStellarProposeAddEModeCategoryTx(opts: StellarBuilderOptions, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_remove_e_mode_category(proposer, id: u32, salt) */
+export declare function buildStellarProposeRemoveEModeCategoryTx(opts: StellarBuilderOptions, args: RemoveEModeCategoryArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_add_asset_to_e_mode(proposer, asset, category_id, can_collateral, can_borrow, ltv, threshold, bonus, salt) */
+export declare function buildStellarProposeAddAssetToEModeTx(opts: StellarBuilderOptions, args: EModeAssetArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_edit_asset_in_e_mode(proposer, asset, category_id, can_collateral, can_borrow, ltv, threshold, bonus, salt) */
+export declare function buildStellarProposeEditAssetInEModeTx(opts: StellarBuilderOptions, args: EModeAssetArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_remove_asset_from_e_mode(proposer, asset: Address, category_id: u32, salt) */
+export declare function buildStellarProposeRemoveAssetFromEModeTx(opts: StellarBuilderOptions, args: RemoveEModeAssetArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_approve_token(proposer, token: Address, salt) */
+export declare function buildStellarProposeApproveTokenTx(opts: StellarBuilderOptions, args: {
+    token: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_revoke_token(proposer, token: Address, salt) */
+export declare function buildStellarProposeRevokeTokenTx(opts: StellarBuilderOptions, args: {
+    token: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_create_liquidity_pool(proposer, asset, params: MarketParamsRaw, config: AssetConfigRaw, salt) */
+export declare function buildStellarProposeCreateLiquidityPoolTx(opts: StellarBuilderOptions, args: CreateLiquidityPoolArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_upgrade_pool_params(proposer, asset, params: InterestRateModel, salt) */
+export declare function buildStellarProposeUpgradePoolParamsTx(opts: StellarBuilderOptions, args: UpgradeLiquidityPoolParamsArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_deploy_pool(proposer, salt) */
+export declare function buildStellarProposeDeployPoolTx(opts: StellarBuilderOptions, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_upgrade_pool(proposer, new_wasm_hash: BytesN<32>, salt) */
+export declare function buildStellarProposeUpgradePoolTx(opts: StellarBuilderOptions, args: {
+    wasmHash: string;
+}, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_grant_controller_role(proposer, account: Address, role: Symbol, salt) */
+export declare function buildStellarProposeGrantControllerRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_revoke_controller_role(proposer, account: Address, role: Symbol, salt) */
+export declare function buildStellarProposeRevokeControllerRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_upgrade_controller(proposer, new_wasm_hash: BytesN<32>, salt) */
+export declare function buildStellarProposeUpgradeControllerTx(opts: StellarBuilderOptions, args: UpgradeArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_migrate_controller(proposer, new_version: u32, salt) */
+export declare function buildStellarProposeMigrateControllerTx(opts: StellarBuilderOptions, args: MigrateArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_transfer_ctrl_ownership(proposer, new_owner: Address, live_until_ledger: u32, salt) */
+export declare function buildStellarProposeTransferCtrlOwnershipTx(opts: StellarBuilderOptions, args: TransferOwnershipArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/**
+ * propose_configure_market_oracle(proposer, asset, cfg: MarketOracleConfigInput, salt)
+ *
+ * The SDK passes the oracle INPUT args verbatim; the contract resolves the
+ * input to a resolved config at propose time (do NOT resolve in the SDK).
+ */
+export declare function buildStellarProposeConfigureMarketOracleTx(opts: StellarBuilderOptions, args: ConfigureMarketOracleArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_edit_oracle_tolerance(proposer, asset, first_tolerance_bps: u32, last_tolerance_bps: u32, salt) */
+export declare function buildStellarProposeEditOracleToleranceTx(opts: StellarBuilderOptions, args: EditOracleToleranceArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_governance_upgrade(proposer, new_wasm_hash: BytesN<32>, salt) */
+export declare function buildStellarProposeGovernanceUpgradeTx(opts: StellarBuilderOptions, args: UpgradeArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_update_delay(proposer, new_delay: u32, salt) */
+export declare function buildStellarProposeUpdateDelayTx(opts: StellarBuilderOptions, args: UpdateDelayArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_grant_governance_role(proposer, account: Address, role: Symbol, salt) */
+export declare function buildStellarProposeGrantGovernanceRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_revoke_governance_role(proposer, account: Address, role: Symbol, salt) */
+export declare function buildStellarProposeRevokeGovernanceRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** propose_transfer_gov_own(proposer, new_owner: Address, live_until_ledger: u32, salt) */
+export declare function buildStellarProposeTransferGovOwnTx(opts: StellarBuilderOptions, args: TransferOwnershipArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+export interface StellarGovernanceExecuteArgs {
+    /** Controller (or other) contract the scheduled op targets. */
+    target: string;
+    /** Controller method name → Soroban `Symbol`. */
+    functionName: string;
+    /**
+     * The controller-call args, each a base64 ScVal XDR string. These must be the
+     * SAME ScVals the matching `propose_*` scheduled (the timelock hashes them
+     * into the op id), in the controller method's arg order. Reconstructed via
+     * `xdr.ScVal.fromXDR(s, 'base64')`.
+     */
+    argsXdr: string[];
+    /** `salt: BytesN<32>` — the same salt used at propose time. */
+    salt: StellarGovernanceSalt;
+    /**
+     * `predecessor: BytesN<32>` — defaults to the 32-zero-byte value used for
+     * every op in this system. Override only if a non-zero predecessor is used.
+     */
+    predecessor?: StellarGovernanceSalt;
+}
+/**
+ * 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.
+ */
+export declare function buildStellarGovernanceExecuteTx(opts: StellarBuilderOptions, args: StellarGovernanceExecuteArgs): BuiltStellarTx;
+/** execute_governance_upgrade(executor=None, new_wasm_hash: BytesN<32>, salt) */
+export declare function buildStellarGovernanceExecuteGovernanceUpgradeTx(opts: StellarBuilderOptions, args: UpgradeArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** execute_update_delay(executor=None, new_delay: u32, salt) */
+export declare function buildStellarGovernanceExecuteUpdateDelayTx(opts: StellarBuilderOptions, args: UpdateDelayArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** execute_grant_governance_role(executor=None, account: Address, role: Symbol, salt) */
+export declare function buildStellarGovernanceExecuteGrantGovernanceRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** execute_revoke_governance_role(executor=None, account: Address, role: Symbol, salt) */
+export declare function buildStellarGovernanceExecuteRevokeGovernanceRoleTx(opts: StellarBuilderOptions, args: RoleGrantArgs, salt: StellarGovernanceSalt): BuiltStellarTx;
+/** execute_transfer_gov_own(executor=None, new_owner: Address, live_until_ledger: u32, salt) */
+export declare function buildStellarGovernanceExecuteTransferGovOwnTx(opts: StellarBuilderOptions, args: TransferOwnershipArgs, salt: StellarGovernanceSalt): BuiltStellarTx;

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

@@ -0,0 +1,11 @@
+export * from './contracts';
+export * from './lending';
+export * from './admin';
+export * from './governance';
+export * from './events';
+export * from './quote';
+export * from './swap';
+export * from './prepare';
+export * from './position-mode';
+export * from './repay-swap';
+export * from './cctp';