@xoxno/types 1.0.479 → 1.0.481

package/dist/stellar-lending/documents/account-delegate.doc.d.ts

@@ -0,0 +1,28 @@
+import { StellarLendingDataType } from '../enums';
+/**
+ * One position-authorization grant, event-sourced from `account:delegate`.
+ *
+ * A delegate may act on the owner's position, so this is security-relevant
+ * state, not display metadata. One document per `(accountId, delegate)` for the
+ * same reason as {@link StellarContractRoleDoc}: anyone can be delegated, so the
+ * set is externally sized and an array field would race under concurrent ticks.
+ *
+ * Revocation flips `granted` to `false` rather than deleting, so a revoke that
+ * arrives before its grant cannot be undone by a later replay.
+ */
+export declare class StellarAccountDelegateDoc {
+    dataType: StellarLendingDataType;
+    /** On-chain numeric account id the delegation applies to. */
+    accountId: number;
+    /** Wallet that owns the account. */
+    owner: string;
+    /** Wallet authorized to act on the account. */
+    delegate: string;
+    granted: boolean;
+    updatedAt: number;
+    ledger: number;
+    id: string;
+    pk: string;
+    _ts?: number;
+    constructor(props?: Partial<StellarAccountDelegateDoc>);
+}

package/dist/stellar-lending/documents/account-delegate.doc.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarAccountDelegateDoc = void 0;
+const enums_1 = require("../enums");
+/**
+ * One position-authorization grant, event-sourced from `account:delegate`.
+ *
+ * A delegate may act on the owner's position, so this is security-relevant
+ * state, not display metadata. One document per `(accountId, delegate)` for the
+ * same reason as {@link StellarContractRoleDoc}: anyone can be delegated, so the
+ * set is externally sized and an array field would race under concurrent ticks.
+ *
+ * Revocation flips `granted` to `false` rather than deleting, so a revoke that
+ * arrives before its grant cannot be undone by a later replay.
+ */
+class StellarAccountDelegateDoc {
+    constructor(props) {
+        this.dataType = enums_1.StellarLendingDataType.ACCOUNT_DELEGATE;
+        this.granted = false;
+        this.updatedAt = 0;
+        this.ledger = 0;
+        Object.assign(this, props);
+        this.pk = this.dataType;
+        this.id = `accountDelegate:${this.accountId}:${this.delegate}`;
+    }
+}
+exports.StellarAccountDelegateDoc = StellarAccountDelegateDoc;

package/dist/stellar-lending/documents/blend-pool.doc.d.ts

@@ -0,0 +1,22 @@
+import { StellarLendingDataType } from '../enums';
+/**
+ * Approval state for one Blend pool, event-sourced from
+ * `config:approve_blend_pool`.
+ *
+ * Approval gates whether positions may migrate into that pool, so the row is
+ * kept after revocation with `approved: false` rather than deleted — a pool that
+ * was once approved and is no longer is materially different from one that never
+ * was, and the difference matters when auditing a migration after the fact.
+ */
+export declare class StellarBlendPoolDoc {
+    dataType: StellarLendingDataType;
+    /** Blend pool contract address. Also the `id` suffix. */
+    pool: string;
+    approved: boolean;
+    updatedAt: number;
+    ledger: number;
+    id: string;
+    pk: string;
+    _ts?: number;
+    constructor(props?: Partial<StellarBlendPoolDoc>);
+}

package/dist/stellar-lending/documents/blend-pool.doc.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarBlendPoolDoc = void 0;
+const enums_1 = require("../enums");
+/**
+ * Approval state for one Blend pool, event-sourced from
+ * `config:approve_blend_pool`.
+ *
+ * Approval gates whether positions may migrate into that pool, so the row is
+ * kept after revocation with `approved: false` rather than deleted — a pool that
+ * was once approved and is no longer is materially different from one that never
+ * was, and the difference matters when auditing a migration after the fact.
+ */
+class StellarBlendPoolDoc {
+    constructor(props) {
+        this.dataType = enums_1.StellarLendingDataType.BLEND_POOL;
+        this.approved = false;
+        this.updatedAt = 0;
+        this.ledger = 0;
+        Object.assign(this, props);
+        this.pk = this.dataType;
+        this.id = `blendPool:${this.pool}`;
+    }
+}
+exports.StellarBlendPoolDoc = StellarBlendPoolDoc;

package/dist/stellar-lending/documents/contract-config.doc.d.ts

@@ -0,0 +1,47 @@
+import { StellarLendingDataType } from '../enums';
+/**
+ * Config and admin state for one deployed contract, event-sourced from that
+ * contract's own `config:*`, pause, ownership and admin events.
+ *
+ * Keyed by contract address rather than being a singleton: the controller,
+ * governance and price-aggregator each emit `ownership_transfer` and each owns
+ * part of this surface, so one document per contract covers all three with a
+ * single materializer. A redeploy writes a new row instead of overwriting the
+ * previous deployment's final state.
+ *
+ * Every field is optional-by-absence: a contract only ever populates the fields
+ * its own events carry, so a governance row leaves the controller fields null
+ * and vice versa.
+ */
+export declare class StellarContractConfigDoc {
+    dataType: StellarLendingDataType;
+    /** Contract this row describes. Also the `id` suffix. */
+    contractAddress: string;
+    /** Set when the deploy was observed via `governance:deploy_*`. */
+    wasmHash: string | null;
+    accumulator: string | null;
+    swapAggregator: string | null;
+    priceAggregator: string | null;
+    maxSupplyPositions: number | null;
+    maxBorrowPositions: number | null;
+    /** Raw 18-decimal WAD from `config:min_borrow_collateral`. */
+    minBorrowCollateralUsdWad: string | null;
+    /** `true` between `paused` and `unpaused`; null until either is seen. */
+    paused: boolean | null;
+    /** Timelock delay in ledgers, from `min_delay_changed`. */
+    minDelayLedgers: number | null;
+    owner: string | null;
+    /** Set by `ownership_transfer`, cleared when the transfer completes. */
+    pendingOwner: string | null;
+    admin: string | null;
+    /** Set by `admin_transfer_initiated`, cleared when the transfer completes. */
+    pendingAdmin: string | null;
+    /** Ledger the pending admin transfer expires at, `0` when cancelled. */
+    pendingAdminLiveUntilLedger: number | null;
+    updatedAt: number;
+    ledger: number;
+    id: string;
+    pk: string;
+    _ts?: number;
+    constructor(props?: Partial<StellarContractConfigDoc>);
+}

package/dist/stellar-lending/documents/contract-config.doc.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarContractConfigDoc = void 0;
+const enums_1 = require("../enums");
+/**
+ * Config and admin state for one deployed contract, event-sourced from that
+ * contract's own `config:*`, pause, ownership and admin events.
+ *
+ * Keyed by contract address rather than being a singleton: the controller,
+ * governance and price-aggregator each emit `ownership_transfer` and each owns
+ * part of this surface, so one document per contract covers all three with a
+ * single materializer. A redeploy writes a new row instead of overwriting the
+ * previous deployment's final state.
+ *
+ * Every field is optional-by-absence: a contract only ever populates the fields
+ * its own events carry, so a governance row leaves the controller fields null
+ * and vice versa.
+ */
+class StellarContractConfigDoc {
+    constructor(props) {
+        this.dataType = enums_1.StellarLendingDataType.CONTRACT_CONFIG;
+        /** Set when the deploy was observed via `governance:deploy_*`. */
+        this.wasmHash = null;
+        // ── Controller (`config:*`, pausable) ──────────────────────────────────
+        this.accumulator = null;
+        this.swapAggregator = null;
+        this.priceAggregator = null;
+        this.maxSupplyPositions = null;
+        this.maxBorrowPositions = null;
+        /** Raw 18-decimal WAD from `config:min_borrow_collateral`. */
+        this.minBorrowCollateralUsdWad = null;
+        /** `true` between `paused` and `unpaused`; null until either is seen. */
+        this.paused = null;
+        // ── Governance (timelock) ──────────────────────────────────────────────
+        /** Timelock delay in ledgers, from `min_delay_changed`. */
+        this.minDelayLedgers = null;
+        // ── Ownable / access-control admin (any contract) ──────────────────────
+        this.owner = null;
+        /** Set by `ownership_transfer`, cleared when the transfer completes. */
+        this.pendingOwner = null;
+        this.admin = null;
+        /** Set by `admin_transfer_initiated`, cleared when the transfer completes. */
+        this.pendingAdmin = null;
+        /** Ledger the pending admin transfer expires at, `0` when cancelled. */
+        this.pendingAdminLiveUntilLedger = null;
+        this.updatedAt = 0;
+        this.ledger = 0;
+        Object.assign(this, props);
+        this.pk = this.dataType;
+        this.id = `contractConfig:${this.contractAddress}`;
+    }
+}
+exports.StellarContractConfigDoc = StellarContractConfigDoc;

package/dist/stellar-lending/documents/contract-role.doc.d.ts

@@ -0,0 +1,32 @@
+import { StellarLendingDataType } from '../enums';
+/**
+ * One access-control grant, event-sourced from `role_granted` / `role_revoked`.
+ *
+ * One document per `(contract, role, account)` rather than a roster array on the
+ * contract: the set of accounts holding a role is externally influenced, so an
+ * array would mean read-modify-write on every event — a lost-update race between
+ * concurrent ticks — and unbounded document growth. As separate rows each event
+ * is a blind idempotent upsert.
+ *
+ * Revocation flips `granted` to `false` rather than deleting the row, so the
+ * grant history stays queryable and a revoke arriving before its grant (replay,
+ * out-of-order paging) cannot resurrect a stale `true`.
+ */
+export declare class StellarContractRoleDoc {
+    dataType: StellarLendingDataType;
+    /** Contract whose access control this grant belongs to. */
+    contractAddress: string;
+    /** On-chain role symbol, e.g. `ORACLE`, `PROPOSER`. */
+    role: string;
+    /** Account holding (or formerly holding) the role. */
+    account: string;
+    granted: boolean;
+    /** Account that performed the grant or revoke. */
+    caller: string | null;
+    updatedAt: number;
+    ledger: number;
+    id: string;
+    pk: string;
+    _ts?: number;
+    constructor(props?: Partial<StellarContractRoleDoc>);
+}

package/dist/stellar-lending/documents/contract-role.doc.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarContractRoleDoc = void 0;
+const enums_1 = require("../enums");
+/**
+ * One access-control grant, event-sourced from `role_granted` / `role_revoked`.
+ *
+ * One document per `(contract, role, account)` rather than a roster array on the
+ * contract: the set of accounts holding a role is externally influenced, so an
+ * array would mean read-modify-write on every event — a lost-update race between
+ * concurrent ticks — and unbounded document growth. As separate rows each event
+ * is a blind idempotent upsert.
+ *
+ * Revocation flips `granted` to `false` rather than deleting the row, so the
+ * grant history stays queryable and a revoke arriving before its grant (replay,
+ * out-of-order paging) cannot resurrect a stale `true`.
+ */
+class StellarContractRoleDoc {
+    constructor(props) {
+        this.dataType = enums_1.StellarLendingDataType.CONTRACT_ROLE;
+        this.granted = false;
+        /** Account that performed the grant or revoke. */
+        this.caller = null;
+        this.updatedAt = 0;
+        this.ledger = 0;
+        Object.assign(this, props);
+        this.pk = this.dataType;
+        this.id = `contractRole:${this.contractAddress}:${this.role}:${this.account}`;
+    }
+}
+exports.StellarContractRoleDoc = StellarContractRoleDoc;

package/dist/stellar-lending/documents/cursor.doc.d.ts

@@ -4,11 +4,25 @@ export declare class StellarLendingCursorDoc {
     lastLedger: number;
     lastPagingToken: string | null;
     /**
-     * Controller the cursor position belongs to. A fresh protocol deployment
-     * changes this address; the indexer discards a mismatched cursor and
-     * reseeds from the configured start ledger so setup events are not skipped.
+     * Watch set the cursor position belongs to. A position is only valid for the
+     * exact set of contracts it was recorded against: any of them being
+     * redeployed or repointed leaves that contract's setup events behind the
+     * stored position, and the cursor only moves forward, so resuming would skip
+     * them permanently. The indexer discards a mismatched cursor and reseeds from
+     * the configured start ledger.
+     *
+     * Binding on the controller alone is what let a price-aggregator repoint slip
+     * through and leave every `StellarAssetDoc.oracleProvider` null.
      */
     controllerAddress: string | null;
+    poolAddress: string | null;
+    priceAggregatorAddress: string | null;
+    governanceAddress: string | null;
+    /**
+     * Decode-logic version. Bumping it discards the cursor and replays everything
+     * within RPC retention, so a decoder fix reaches already-indexed events.
+     */
+    indexerVersion: string | null;
     updatedAt: number;
     id: string;
     pk: string;

package/dist/stellar-lending/documents/cursor.doc.js

@@ -8,11 +8,25 @@ class StellarLendingCursorDoc {
         this.lastLedger = 0;
         this.lastPagingToken = null;
         /**
-         * Controller the cursor position belongs to. A fresh protocol deployment
-         * changes this address; the indexer discards a mismatched cursor and
-         * reseeds from the configured start ledger so setup events are not skipped.
+         * Watch set the cursor position belongs to. A position is only valid for the
+         * exact set of contracts it was recorded against: any of them being
+         * redeployed or repointed leaves that contract's setup events behind the
+         * stored position, and the cursor only moves forward, so resuming would skip
+         * them permanently. The indexer discards a mismatched cursor and reseeds from
+         * the configured start ledger.
+         *
+         * Binding on the controller alone is what let a price-aggregator repoint slip
+         * through and leave every `StellarAssetDoc.oracleProvider` null.
          */
         this.controllerAddress = null;
+        this.poolAddress = null;
+        this.priceAggregatorAddress = null;
+        this.governanceAddress = null;
+        /**
+         * Decode-logic version. Bumping it discards the cursor and replays everything
+         * within RPC retention, so a decoder fix reaches already-indexed events.
+         */
+        this.indexerVersion = null;
         this.updatedAt = 0;
         Object.assign(this, props);
         this.pk = this.dataType;

package/dist/stellar-lending/documents/index.d.ts

@@ -5,4 +5,8 @@ export * from './spoke.doc';
 export * from './spoke-asset.doc';
 export * from './account-position.doc';
 export * from './governance-proposal.doc';
+export * from './contract-config.doc';
+export * from './contract-role.doc';
+export * from './account-delegate.doc';
+export * from './blend-pool.doc';
 export * from './cursor.doc';

package/dist/stellar-lending/documents/index.js

@@ -21,4 +21,8 @@ __exportStar(require("./spoke.doc"), exports);
 __exportStar(require("./spoke-asset.doc"), exports);
 __exportStar(require("./account-position.doc"), exports);
 __exportStar(require("./governance-proposal.doc"), exports);
+__exportStar(require("./contract-config.doc"), exports);
+__exportStar(require("./contract-role.doc"), exports);
+__exportStar(require("./account-delegate.doc"), exports);
+__exportStar(require("./blend-pool.doc"), exports);
 __exportStar(require("./cursor.doc"), exports);

package/dist/stellar-lending/enums/activity.enum.d.ts

@@ -19,3 +19,32 @@ export declare enum StellarLendingActivity {
     InitialPayment = "initialPayment",
     Unknown = "unknown"
 }
+/**
+ * Protocol-level changes that alter contract config, access control or
+ * authorization rather than a user's position.
+ *
+ * Separate from {@link StellarLendingActivity} and Stellar-only by construction:
+ * MVX Kusto ingestion policies match on the position activity values, so these
+ * rows are never picked up by them. Same reasoning as
+ * `STELLAR_LENDING_MARKET_STATE_ACTIVITY` in the indexer.
+ */
+export declare enum StellarProtocolActivity {
+    AccumulatorSet = "stellarAccumulatorSet",
+    SwapAggregatorSet = "stellarSwapAggregatorSet",
+    PriceAggregatorSet = "stellarPriceAggregatorSet",
+    PositionLimitsSet = "stellarPositionLimitsSet",
+    MinBorrowCollateralSet = "stellarMinBorrowCollateralSet",
+    BlendPoolApprovalSet = "stellarBlendPoolApprovalSet",
+    Paused = "stellarPaused",
+    Unpaused = "stellarUnpaused",
+    OwnershipTransferStarted = "stellarOwnershipTransferStarted",
+    OwnershipTransferred = "stellarOwnershipTransferred",
+    AdminTransferStarted = "stellarAdminTransferStarted",
+    AdminTransferred = "stellarAdminTransferred",
+    RoleGranted = "stellarRoleGranted",
+    RoleRevoked = "stellarRoleRevoked",
+    DelegateGranted = "stellarDelegateGranted",
+    DelegateRevoked = "stellarDelegateRevoked",
+    MinDelayChanged = "stellarMinDelayChanged",
+    ContractDeployed = "stellarContractDeployed"
+}

package/dist/stellar-lending/enums/activity.enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StellarLendingActivity = void 0;
+exports.StellarProtocolActivity = exports.StellarLendingActivity = void 0;
 var StellarLendingActivity;
 (function (StellarLendingActivity) {
     StellarLendingActivity["Supply"] = "supply";
@@ -23,3 +23,33 @@ var StellarLendingActivity;
     StellarLendingActivity["InitialPayment"] = "initialPayment";
     StellarLendingActivity["Unknown"] = "unknown";
 })(StellarLendingActivity || (exports.StellarLendingActivity = StellarLendingActivity = {}));
+/**
+ * Protocol-level changes that alter contract config, access control or
+ * authorization rather than a user's position.
+ *
+ * Separate from {@link StellarLendingActivity} and Stellar-only by construction:
+ * MVX Kusto ingestion policies match on the position activity values, so these
+ * rows are never picked up by them. Same reasoning as
+ * `STELLAR_LENDING_MARKET_STATE_ACTIVITY` in the indexer.
+ */
+var StellarProtocolActivity;
+(function (StellarProtocolActivity) {
+    StellarProtocolActivity["AccumulatorSet"] = "stellarAccumulatorSet";
+    StellarProtocolActivity["SwapAggregatorSet"] = "stellarSwapAggregatorSet";
+    StellarProtocolActivity["PriceAggregatorSet"] = "stellarPriceAggregatorSet";
+    StellarProtocolActivity["PositionLimitsSet"] = "stellarPositionLimitsSet";
+    StellarProtocolActivity["MinBorrowCollateralSet"] = "stellarMinBorrowCollateralSet";
+    StellarProtocolActivity["BlendPoolApprovalSet"] = "stellarBlendPoolApprovalSet";
+    StellarProtocolActivity["Paused"] = "stellarPaused";
+    StellarProtocolActivity["Unpaused"] = "stellarUnpaused";
+    StellarProtocolActivity["OwnershipTransferStarted"] = "stellarOwnershipTransferStarted";
+    StellarProtocolActivity["OwnershipTransferred"] = "stellarOwnershipTransferred";
+    StellarProtocolActivity["AdminTransferStarted"] = "stellarAdminTransferStarted";
+    StellarProtocolActivity["AdminTransferred"] = "stellarAdminTransferred";
+    StellarProtocolActivity["RoleGranted"] = "stellarRoleGranted";
+    StellarProtocolActivity["RoleRevoked"] = "stellarRoleRevoked";
+    StellarProtocolActivity["DelegateGranted"] = "stellarDelegateGranted";
+    StellarProtocolActivity["DelegateRevoked"] = "stellarDelegateRevoked";
+    StellarProtocolActivity["MinDelayChanged"] = "stellarMinDelayChanged";
+    StellarProtocolActivity["ContractDeployed"] = "stellarContractDeployed";
+})(StellarProtocolActivity || (exports.StellarProtocolActivity = StellarProtocolActivity = {}));

package/dist/stellar-lending/enums/data-type.enum.d.ts

@@ -5,6 +5,19 @@ export declare enum StellarLendingDataType {
     SPOKE = "spoke",
     SPOKE_ASSET = "spokeAsset",
     ACCOUNT_POSITION = "accountPosition",
-    GOVERNANCE_PROPOSAL = "governanceProposal",
+    /**
+     * Deliberately not `governanceProposal`: MVX lending uses that partition key
+     * with the same `operationId` document id and no chain discriminator, so the
+     * two chains' proposals would be indistinguishable in one partition.
+     */
+    GOVERNANCE_PROPOSAL = "stellarGovernanceProposal",
+    /** Per-contract config + admin state, keyed by contract address. */
+    CONTRACT_CONFIG = "contractConfig",
+    /** One row per (contract, role, account) access-control grant. */
+    CONTRACT_ROLE = "contractRole",
+    /** One row per (account, delegate) position-authorization grant. */
+    ACCOUNT_DELEGATE = "accountDelegate",
+    /** One row per Blend pool the controller has approved or revoked. */
+    BLEND_POOL = "blendPool",
     CURSOR = "cursor"
 }

package/dist/stellar-lending/enums/data-type.enum.js

@@ -9,6 +9,19 @@ var StellarLendingDataType;
     StellarLendingDataType["SPOKE"] = "spoke";
     StellarLendingDataType["SPOKE_ASSET"] = "spokeAsset";
     StellarLendingDataType["ACCOUNT_POSITION"] = "accountPosition";
-    StellarLendingDataType["GOVERNANCE_PROPOSAL"] = "governanceProposal";
+    /**
+     * Deliberately not `governanceProposal`: MVX lending uses that partition key
+     * with the same `operationId` document id and no chain discriminator, so the
+     * two chains' proposals would be indistinguishable in one partition.
+     */
+    StellarLendingDataType["GOVERNANCE_PROPOSAL"] = "stellarGovernanceProposal";
+    /** Per-contract config + admin state, keyed by contract address. */
+    StellarLendingDataType["CONTRACT_CONFIG"] = "contractConfig";
+    /** One row per (contract, role, account) access-control grant. */
+    StellarLendingDataType["CONTRACT_ROLE"] = "contractRole";
+    /** One row per (account, delegate) position-authorization grant. */
+    StellarLendingDataType["ACCOUNT_DELEGATE"] = "accountDelegate";
+    /** One row per Blend pool the controller has approved or revoked. */
+    StellarLendingDataType["BLEND_POOL"] = "blendPool";
     StellarLendingDataType["CURSOR"] = "cursor";
 })(StellarLendingDataType || (exports.StellarLendingDataType = StellarLendingDataType = {}));

package/dist/stellar-lending/list.d.ts

@@ -38,7 +38,21 @@ export interface StellarAssetListItem {
     hubCount: number;
     /** Number of reserves (spoke,hub) for this asset. */
     marketCount: number;
+    /**
+     * The two underlying token SACs when this asset is an AMM LP share, so
+     * clients can render the pair (both leg logos) instead of one unresolvable
+     * logo for the share itself.
+     *
+     * Projected from the asset's indexed `LpShare` price source
+     * (`StellarAssetOracle.sources[]`). Present only when BOTH legs are
+     * `{ Token }` price keys — a `{ Ref }` leg is registry-only and has no SAC,
+     * so there is nothing to render. Consumers may therefore treat "present" as
+     * "renderable pair" with no partial case to handle.
+     */
+    lpUnderlying?: StellarLpUnderlying;
 }
+/** The two leg SACs of an LP share, in the pool's `[keyA, keyB]` order. */
+export type StellarLpUnderlying = [tokenA: string, tokenB: string];
 /** One (spoke, hub) market row for an asset detail page. */
 export interface StellarAssetPageMarket {
     spokeId: number;

package/dist/stellar-lending/oracle-provider.d.ts

@@ -5,6 +5,17 @@
  * Mirrors on-chain `PriceKey` + `AssetOracle` (`sources`, independence,
  * tolerance, sanity). `i128` → string; `u32/u64` → number. No Nest
  * decorators — api-v2 owns swagger DTOs; this package owns wire shapes.
+ *
+ * These are the NORMALIZED shapes, not what `scValToNative` hands back. Soroban
+ * renders a payload-carrying enum variant as a `[variant, payload]` tuple and a
+ * unit variant as a one-element `[variant]` tuple, with snake_case fields. The
+ * indexer's decoders convert both into the object form below before persisting:
+ *
+ *   ["AquariusLp", { key_a, … }] → { AquariusLp: { keyA, … } }
+ *   ["RequireDisjoint"]          → 'RequireDisjoint'
+ *
+ * Anything assigning raw `scValToNative` output to these types is a bug — the
+ * shapes differ and a type assertion will hide it.
  */
 /** On-chain `PriceKey`: Token SAC or registry-only Ref symbol. */
 export type StellarPriceKey = {
@@ -12,8 +23,6 @@ export type StellarPriceKey = {
 } | {
     Ref: string;
 };
-/** On-chain `ProviderKind`. */
-export type StellarProviderKind = 'Reflector' | 'RedStone' | 'Xoxno';
 /** On-chain `FeedNature`. */
 export type StellarFeedNature = 'Market' | 'Fundamental';
 /** On-chain `OracleAssetRef` for Reflector legs. */
@@ -38,17 +47,22 @@ export interface StellarReflectorFeedRef {
     asset: StellarOracleAssetRef;
     readMode: StellarOracleReadMode;
 }
+/** On-chain `MultiFeedRef`, shared by the RedStone and Xoxno legs. */
 export interface StellarMultiFeedRef {
     contract: string;
     feedId: string;
-    kind: StellarProviderKind;
     nature: StellarFeedNature;
 }
-/** On-chain `ProviderRef`. */
+/**
+ * On-chain `ProviderRef`. The provider kind IS the variant — RedStone and Xoxno
+ * both carry a `MultiFeedRef`, and are told apart by which key is present.
+ */
 export type StellarProviderRef = {
     Reflector: StellarReflectorFeedRef;
 } | {
-    MultiFeed: StellarMultiFeedRef;
+    RedStone: StellarMultiFeedRef;
+} | {
+    Xoxno: StellarMultiFeedRef;
 };
 export interface StellarFeedSource {
     provider: StellarProviderRef;
@@ -61,31 +75,42 @@ export interface StellarScaledSource {
     minFactorWad: string;
     maxFactorWad: string;
 }
-export type StellarPoolKind = 'ConstantProduct';
-export interface StellarLpShareSource {
+/**
+ * On-chain `AquariusLpSource` — prices an Aquarius LP share token from its two
+ * reserve legs. `plane` is the pool-info contract the aggregator reads reserves
+ * from; `minPoolValueWad` is the liquidity floor below which the source is
+ * rejected.
+ */
+export interface StellarAquariusLpSource {
     pool: string;
-    kind: StellarPoolKind;
+    plane: string;
+    tokenA: string;
+    tokenB: string;
     keyA: StellarPriceKey;
     keyB: StellarPriceKey;
     reserveADecimals: number;
     reserveBDecimals: number;
-    shareDecimals: number;
+    minPoolValueWad: string;
 }
-/** On-chain `PriceSource`. */
+/**
+ * On-chain `PriceSource`. Both Aquarius variants carry an `AquariusLpSource`;
+ * the stable variant differs only in the curve the aggregator prices against.
+ */
 export type StellarPriceSource = {
     Feed: StellarFeedSource;
 } | {
     Scaled: StellarScaledSource;
 } | {
-    LpShare: StellarLpShareSource;
+    AquariusLp: StellarAquariusLpSource;
+} | {
+    AquariusStableLp: StellarAquariusLpSource;
 };
-export interface StellarTrustDomain {
-    kind: StellarProviderKind;
-    contract: string;
-}
-/** On-chain `IndependencePolicy`. */
+/**
+ * On-chain `IndependencePolicy`. `AllowShared` carries the provider contract
+ * addresses two legs are permitted to have in common.
+ */
 export type StellarIndependencePolicy = 'RequireDisjoint' | {
-    AllowShared: StellarTrustDomain[];
+    AllowShared: string[];
 };
 /**
  * On-chain `AssetOracle` — one or two independent opinions for a `PriceKey`.
@@ -101,9 +126,3 @@ export interface StellarAssetOracle {
     minSanityPriceWad: string;
     maxSanityPriceWad: string;
 }
-/**
- * @deprecated Alias of {@link StellarAssetOracle}. Prefer `StellarAssetOracle`.
- * Kept so existing imports continue to resolve while consumers migrate off the
- * v1 primary/anchor flat projection.
- */
-export type StellarOracleProvider = StellarAssetOracle;

package/dist/stellar-lending/oracle-provider.js

@@ -6,5 +6,16 @@
  * Mirrors on-chain `PriceKey` + `AssetOracle` (`sources`, independence,
  * tolerance, sanity). `i128` → string; `u32/u64` → number. No Nest
  * decorators — api-v2 owns swagger DTOs; this package owns wire shapes.
+ *
+ * These are the NORMALIZED shapes, not what `scValToNative` hands back. Soroban
+ * renders a payload-carrying enum variant as a `[variant, payload]` tuple and a
+ * unit variant as a one-element `[variant]` tuple, with snake_case fields. The
+ * indexer's decoders convert both into the object form below before persisting:
+ *
+ *   ["AquariusLp", { key_a, … }] → { AquariusLp: { keyA, … } }
+ *   ["RequireDisjoint"]          → 'RequireDisjoint'
+ *
+ * Anything assigning raw `scValToNative` output to these types is a bug — the
+ * shapes differ and a type assertion will hide it.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xoxno/types",
-  "version": "1.0.479",
+  "version": "1.0.481",
   "description": "Shared types and utilities for XOXNO API.",
   "exports": {
     ".": {