@augustdigital/sdk 9.0.0 → 9.2.0

package/lib/sdk.d.ts

@@ -15112,6 +15112,30 @@ export declare type ApproveResult =
     kind: 'native';
 };
 
+/**
+ * Whether an alert would be sent right now.
+ *
+ * Quiet by default outside production, mirroring `analytics`: a partner's Jest
+ * suite or `next dev` session exercising a failing redeem must not page a real
+ * curator. Two gates are needed for that, because they cover different
+ * runtimes — `NODE_ENV` is the Node one, and bundlers strip or stub
+ * `process.env` in the browser, so a locally-served app is recognised by its
+ * hostname instead (CLAUDE.md §5). Without that gate, a browser app run
+ * against mainnet from any loopback or private origin — `localhost`, a
+ * container on `172.20.0.0/16`, `[::1]` — pages a real curator on every
+ * failed redeem. `isLocalhost` in `core/analytics/env` lists the ranges.
+ *
+ * `enabled: true` overrides both — it is the documented way to exercise the
+ * path deliberately, and the SDK's own suite relies on it.
+ *
+ * The env var is read per call (not once at module load) so a consumer that
+ * sets it after import is still honoured, and a test can set and unset it
+ * without re-importing. It deliberately outranks an explicit `enabled: true`:
+ * it is the kill switch, and an operator setting it should not have to find
+ * and edit the construction site to be obeyed.
+ */
+export declare function areCuratorAlertsEnabled(): boolean;
+
 declare type AsArray<T> = T extends readonly unknown[] ? T : never;
 
 /**
@@ -16047,6 +16071,12 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                    * `cefi` / `otc` arrays back the drill-downs. See the "Rendering the Vault
                    * Exposure section" guide in the vaults docs for a faithful reproduction.
                    *
+                   * Stellar vaults resolve their DeFi exposure through the Untangled portfolio
+                   * API instead of DeBank — one extra HTTP call, covering the idle buffer,
+                   * Stellar protocol positions, custody wallets and bridged capital. If that
+                   * call fails the exposure legs come back empty rather than throwing, so CeFi,
+                   * OTC and loan allocations still resolve.
+                   *
                    * @param props - Vault address and chain ID
                    * @returns Detailed breakdown of vault allocations by category
                    * @example
@@ -17530,6 +17560,23 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                       */
                      export declare function computeArgShape(args: unknown[]): string[];
 
+                     /**
+                      * Apply constructor config. Called unconditionally by `AugustBase` so an
+                      * instance that omits `curatorAlerts` RESETS to the defaults rather than
+                      * inheriting a prior instance's settings — same contract as
+                      * `setPublicApiBaseUrl` and `setAttribution`.
+                      *
+                      * Also the supported opt-out for code that calls the `Stellar` namespace
+                      * functions directly without constructing an `AugustSDK` (the testnet flow in
+                      * the docs), and the only one that works in a browser, where the env var is
+                      * unreadable.
+                      *
+                      * @param config - `monitoring.curatorAlerts`, or `null` to restore defaults.
+                      * @param context - Facts about the reporting instance; omitted entirely by a
+                      *   caller that only wants to disable reporting.
+                      */
+                     export declare function configureCuratorAlerts(config: ICuratorAlertsConfig | null, context?: ICuratorAlertsContext): void;
+
                      /**
                       * Query the vault's `convert_to_shares` to preview how many shares a deposit
                       * amount would yield.  Returns the raw share amount as a string, or null on
@@ -17627,6 +17674,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                       */
                      export declare function crossChainVaultRedeem(props: ICrossChainRedeemRequest): Promise<ICrossChainRedeemResult>;
 
+                     /** Env equivalent of `monitoring.curatorAlerts.enabled: false`. Node only. */
+                     export declare const CURATOR_ALERTS_DISABLE_ENV_VAR = "AUGUST_SDK_DISABLE_CURATOR_ALERTS";
+
                      /**
                       * Datetime
                       */
@@ -19355,6 +19405,15 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                   * Fetch comprehensive vault asset allocation breakdown.
                                   * Includes DeFi protocols (via DeBank), CeFi balances, OTC positions, and loans.
                                   * Categorizes exposures by borrowing, supplying, lending, and wallet holdings.
+                                  *
+                                  * DeFi exposure resolves per chain family: EVM vaults via DeBank, Solana
+                                  * borrowers via Octav.fi, and Stellar vaults via the Untangled portfolio API —
+                                  * one vault-level call covering the idle buffer, Stellar protocol positions,
+                                  * custody wallets, and capital bridged to other chains. The Stellar path adds
+                                  * exactly 1 HTTP call and zero for every other chain; when it fails, the
+                                  * exposure section comes back empty and the CeFi, OTC and loan allocations are
+                                  * still returned.
+                                  *
                                   * @param vault - Vault address
                                   * @param options - RPC configuration
                                   * @returns Detailed allocation data with exposure categorization
@@ -19810,6 +19869,19 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                   * `redeem(shares: i128, receiver, owner, operator) -> i128`; divergence
                                   * surfaces as a generic Soroban simulation error.
                                   *
+                                  * Side effect on failure: when the *vault* cannot serve the redemption — it
+                                  * rejected the call, or its ledger state needs restoring — the failure is
+                                  * reported to that vault's curator. Stellar vaults are instant-redeem only, so
+                                  * this is the curator's only signal that their depositors cannot get out
+                                  * (AUGUST-7162). Fire-and-forget and deduped; see
+                                  * {@link reportRedeemFailure} and {@link REPORTED_BUILD_STAGES}.
+                                  *
+                                  * Note this includes a caller-caused rejection such as redeeming more shares
+                                  * than the wallet holds: the contract trapping is what we can observe, and
+                                  * telling that apart from a vault-side problem needs the vault's error
+                                  * taxonomy. A bad address, an unfunded account, and an exhausted RPC failover
+                                  * are excluded — none of those reached the vault.
+                                  *
                                   * @returns Base64-encoded XDR ready for wallet signing; pass the signed
                                   *   XDR to {@link submitStellarTransaction}.
                                   */
@@ -20409,6 +20481,46 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                      hubOnlyReceipt?: boolean;
                                  }
 
+                                 /** Curator-alert reporting. Enabled by default; this is the opt-out. */
+                                 export declare interface ICuratorAlertsConfig {
+                                     /**
+                                      * `false` stops emitting entirely. `true` forces emitting even in an
+                                      * environment the SDK would otherwise stay quiet in — it bypasses **every**
+                                      * environment gate: `NODE_ENV` of `development`/`test`, a browser served
+                                      * from a loopback or private host, and `monitoring.env` other than `PROD`.
+                                      * It does NOT lift the mainnet-only restriction; only `endpoint` does. A
+                                      * `DEV` or test
+                                      * integration that sets it and then fails a mainnet redeem pages a real
+                                      * curator, so use it only when deliberately exercising the path (pair it
+                                      * with `endpoint` to aim at a test relay). The only thing that still wins is
+                                      * the {@link CURATOR_ALERTS_DISABLE_ENV_VAR} kill switch.
+                                      */
+                                     enabled?: boolean;
+                                     /**
+                                      * Override the relay endpoint. Defaults to
+                                      * {@link DEFAULT_CURATOR_ALERT_ENDPOINT}. Setting it also lifts the
+                                      * mainnet-only restriction, so a staging relay can receive testnet failures.
+                                      */
+                                     endpoint?: string;
+                                 }
+
+                                 /** Ambient facts about the reporting SDK instance, supplied by `AugustBase`. */
+                                 export declare interface ICuratorAlertsContext {
+                                     /** Carried on the payload so August can tell partner traffic apart. */
+                                     appName?: string;
+                                     /**
+                                      * `monitoring.env`. Anything other than `'PROD'` keeps the SDK quiet unless
+                                      * `config.enabled` is explicitly `true`.
+                                      */
+                                     environment?: IEnv;
+                                     /**
+                                      * Effective base URL of the August public API. Reports follow the API this
+                                      * instance reads from, so a deployment pointed at a staging backend alerts
+                                      * staging rather than production.
+                                      */
+                                     apiBaseUrl?: string;
+                                 }
+
                                  /**
                                   * On-chain whitelist status of one subaccount linked to a vault, from
                                   * `GET /curator/vaults/{vault_address}/whitelist` (backend
@@ -20954,6 +21066,27 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                  declare interface IMonitoring extends IWSMonitorHeaders {
                                      slackWebhookUrl?: string;
                                      env?: IEnv;
+                                     /**
+                                      * Curator notifications for failed vault redemptions. Enabled by default
+                                      * (opt-out model, like `analytics`).
+                                      *
+                                      * Stellar vaults are instant-redeem only, so when a redemption fails the
+                                      * vault's curator has no other way to learn about it. The SDK relays the
+                                      * failure to August's notification service, which routes it to that curator's
+                                      * own channel — no credentials or curator identities are held here.
+                                      *
+                                      * Set `enabled: false` (or, in Node, the
+                                      * `AUGUST_SDK_DISABLE_CURATOR_ALERTS` env var) to stop emitting; set
+                                      * `endpoint` only to point a non-prod deployment at a test relay. Nothing is
+                                      * emitted unless `monitoring.env` is `PROD`, `NODE_ENV` is neither
+                                      * `development` nor `test`, and — in a browser, where `NODE_ENV` is not
+                                      * readable — the page is not served from localhost.
+                                      *
+                                      * `enabled: true` is the one exception: it bypasses all three gates, so a
+                                      * `DEV` or test integration that sets it can page a real curator. See
+                                      * {@link ICuratorAlertsConfig}.
+                                      */
+                                     curatorAlerts?: ICuratorAlertsConfig;
                                  }
 
                                  /* Excluded from this release type: IMulticall3Request */
@@ -26112,10 +26245,22 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                            vaultDeposit(params: Omit<IStellarDepositParams, 'network'>): Promise<string>;
                                            /**
                                             * Build an unsigned redeem transaction for a Stellar vault.
+                                            *
+                                            * Side effect on failure: a redemption the vault cannot serve is reported to
+                                            * that vault's curator, since Stellar vaults are instant-redeem only and this
+                                            * is the curator's only signal. Fire-and-forget — it never delays or alters
+                                            * the error you receive. On by default in production; see
+                                            * `monitoring.curatorAlerts` and the Curator Notifications section of the
+                                            * Stellar Actions guide for exactly what is sent and how to opt out.
+                                            *
                                             * @returns Base64-encoded XDR of the unsigned transaction.
                                             */
                                            vaultRedeem(params: Omit<IStellarRedeemParams, 'network'>): Promise<string>;
                                            /**
+                                            * Side effect: a submitted transaction that the network reports as a failed
+                                            * `redeem` operation is reported to that vault's curator, on the same
+                                            * fire-and-forget terms as {@link StellarAdapter.vaultRedeem}.
+                                            *
                                             * Submit a signed Soroban transaction and poll until the network confirms it.
                                             *
                                             * Submits on the network this adapter was constructed with, so `signedXdr`
@@ -26227,6 +26372,14 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                      *   plus, when the result XDR decodes, a `resultCode` string holding the
                                                      *   transaction-level reason (e.g. `"txBadSeq"`, `"txTooLate"`); `resultCode`
                                                      *   is `undefined` when the code cannot be decoded.
+                                                     *
+                                                     * Side effect: a transaction whose `resultCode` is `txFailed` — the operation
+                                                     * itself ran and failed — and whose envelope shows a vault `redeem` is relayed
+                                                     * to that vault's curator (fire-and-forget, deduped — see
+                                                     * {@link reportRedeemFailure}). Nothing else alerts: an RPC-rejected
+                                                     * broadcast is a retryable race, a poll timeout is indeterminate (the
+                                                     * transaction may yet succeed), and any other result code means the redeem
+                                                     * never executed.
                                                      * @example
                                                      * ```ts
                                                      * try {

package/lib/services/untangled/fetcher.d.ts

@@ -0,0 +1,40 @@
+import type { IUntangledVaultExposure } from './types';
+/**
+ * Fetch a vault's full capital exposure from the Untangled portfolio API.
+ *
+ * Untangled reconciles Stellar vaults end to end — the vault's idle buffer,
+ * capital deployed into Stellar protocols, custody wallet balances, and value
+ * bridged to other chains. DeBank and Octav.fi cover none of that, which is why
+ * Stellar vaults previously rendered an empty exposure breakdown.
+ *
+ * The endpoint is keyed by **vault** address and already aggregates every
+ * borrower, so it must be called once per vault — never once per borrower, which
+ * would multiply the same totals.
+ *
+ * Requests are plain `GET`s with no custom headers. That is deliberate: it keeps
+ * them preflight-free in the browser, where the API's `access-control-allow-origin: *`
+ * covers the simple request but a bare `OPTIONS` is rejected.
+ *
+ * Never throws. Every failure — unknown vault, upstream error, transport
+ * failure, malformed body — resolves to `null` so callers can degrade to an
+ * empty exposure section instead of losing the rest of their response.
+ *
+ * Worst case: exactly **1 HTTP call**. No retry, no caching (the API is edge
+ * cached at `s-maxage=60`, well inside its 60 req/min budget for one call per
+ * vault page load).
+ *
+ * @param vault - Vault address, e.g. a Stellar contract address (`C…`).
+ * @returns The resolved exposure report, or `null` when Untangled does not
+ *   reconcile this vault or the request failed.
+ *
+ * @example
+ * ```typescript
+ * const exposure = await fetchUntangledVaultExposure(
+ *   'CCL3WITWFFXIHV2I52ECV5DPIEOFSTU3PBPR53ILPLF2IP5KHECXRUTY',
+ * );
+ * // exposure?.tvlUsd     → 24845637.05
+ * // exposure?.byProtocol → [{ protocolId: 'stellar-wallet', … }, { protocolId: 'blend', … }, …]
+ * const normalized = transformUntangledToDebank(exposure);
+ * ```
+ */
+export declare function fetchUntangledVaultExposure(vault: string): Promise<IUntangledVaultExposure | null>;

package/lib/services/untangled/fetcher.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUntangledVaultExposure = fetchUntangledVaultExposure;
+const core_1 = require("../../core");
+const BASE_URL = 'https://api-portfolio-octopos-mainnet.untangled.finance';
+/**
+ * Read a response body as JSON without throwing.
+ *
+ * Used on the error path, where a malformed or empty body must not mask the
+ * HTTP status we actually want to report.
+ *
+ * @param response - The fetch response to drain.
+ * @returns The parsed body, or `null` when it is absent or not JSON.
+ */
+async function readJsonSafely(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch a vault's full capital exposure from the Untangled portfolio API.
+ *
+ * Untangled reconciles Stellar vaults end to end — the vault's idle buffer,
+ * capital deployed into Stellar protocols, custody wallet balances, and value
+ * bridged to other chains. DeBank and Octav.fi cover none of that, which is why
+ * Stellar vaults previously rendered an empty exposure breakdown.
+ *
+ * The endpoint is keyed by **vault** address and already aggregates every
+ * borrower, so it must be called once per vault — never once per borrower, which
+ * would multiply the same totals.
+ *
+ * Requests are plain `GET`s with no custom headers. That is deliberate: it keeps
+ * them preflight-free in the browser, where the API's `access-control-allow-origin: *`
+ * covers the simple request but a bare `OPTIONS` is rejected.
+ *
+ * Never throws. Every failure — unknown vault, upstream error, transport
+ * failure, malformed body — resolves to `null` so callers can degrade to an
+ * empty exposure section instead of losing the rest of their response.
+ *
+ * Worst case: exactly **1 HTTP call**. No retry, no caching (the API is edge
+ * cached at `s-maxage=60`, well inside its 60 req/min budget for one call per
+ * vault page load).
+ *
+ * @param vault - Vault address, e.g. a Stellar contract address (`C…`).
+ * @returns The resolved exposure report, or `null` when Untangled does not
+ *   reconcile this vault or the request failed.
+ *
+ * @example
+ * ```typescript
+ * const exposure = await fetchUntangledVaultExposure(
+ *   'CCL3WITWFFXIHV2I52ECV5DPIEOFSTU3PBPR53ILPLF2IP5KHECXRUTY',
+ * );
+ * // exposure?.tvlUsd     → 24845637.05
+ * // exposure?.byProtocol → [{ protocolId: 'stellar-wallet', … }, { protocolId: 'blend', … }, …]
+ * const normalized = transformUntangledToDebank(exposure);
+ * ```
+ */
+async function fetchUntangledVaultExposure(vault) {
+    try {
+        const response = await fetch(`${BASE_URL}/v1/vaults/${encodeURIComponent(vault)}/exposure`, { method: 'GET' });
+        if (!response.ok) {
+            const body = await readJsonSafely(response);
+            // 404 is the documented "we don't reconcile this vault" answer, not a
+            // fault — most vaults are not Untangled-covered. Keep it a breadcrumb so
+            // a known, permanent gap does not fill Sentry.
+            if (response.status === 404) {
+                core_1.Logger.log.warn('fetchUntangledVaultExposure:unresolved', {
+                    vault,
+                    status: response.status,
+                    reason: body?.reason ?? 'unknown_vault',
+                });
+                return null;
+            }
+            core_1.Logger.log.error('fetchUntangledVaultExposure', new Error(`HTTP ${response.status} ${response.statusText}`), { vault, status: response.status });
+            return null;
+        }
+        const data = await response.json();
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            core_1.Logger.log.error('fetchUntangledVaultExposure.unexpected-type', new Error(`unexpected response type: ${typeof data}`), { vault });
+            return null;
+        }
+        if (data.resolved !== true) {
+            core_1.Logger.log.warn('fetchUntangledVaultExposure:unresolved', {
+                vault,
+                status: response.status,
+                reason: data.reason ?? 'unknown_vault',
+            });
+            return null;
+        }
+        if (!Array.isArray(data.byProtocol)) {
+            core_1.Logger.log.error('fetchUntangledVaultExposure.malformed', new Error('resolved response is missing byProtocol[]'), { vault });
+            return null;
+        }
+        if (data.stale) {
+            core_1.Logger.log.warn('fetchUntangledVaultExposure:stale', {
+                vault,
+                asOf: data.asOf,
+            });
+        }
+        return data;
+    }
+    catch (error) {
+        core_1.Logger.log.error('fetchUntangledVaultExposure', error, { vault });
+        return null;
+    }
+}
+//# sourceMappingURL=fetcher.js.map

package/lib/services/untangled/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetcher';
+export * from './types';
+export * from './utils';

package/lib/services/untangled/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/lib/services/untangled/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Response types for the Untangled portfolio API.
+ *
+ * Shape verified live on 2026-09-01 against
+ * `GET https://api-portfolio-octopos-mainnet.untangled.finance/v1/vaults/{address}/exposure`
+ * for the Gami earnUSDC Stellar vault.
+ */
+/**
+ * One protocol slice of a vault's TVL.
+ *
+ * Untangled reports the whole vault, so the slices cover capital held in the
+ * vault contract itself, in custody wallets, and bridged to other chains — not
+ * just on-chain Stellar protocol positions.
+ */
+export interface IUntangledProtocolExposure {
+    /**
+     * Untangled protocol slug, e.g. `blend`, `templar`, `aquarius`. Two slugs are
+     * not protocols: `stellar-wallet` (custody wallets) and `upshift` (the vault's
+     * own idle buffer).
+     */
+    protocolId: string;
+    /** USD value held in this protocol. */
+    valueUsd: number;
+    /** Share of the vault's `tvlUsd`, as a percentage (`23.54` means 23.54%). */
+    pct: number;
+}
+/**
+ * One asset slice of a vault's TVL. Vault-wide — the API does not currently
+ * break assets down per protocol.
+ */
+export interface IUntangledAssetExposure {
+    /** Asset ticker, e.g. `USDC`, `XLM`. */
+    symbol: string;
+    /** USD value held in this asset across the whole vault. */
+    valueUsd: number;
+    /** Share of the vault's `tvlUsd`, as a percentage. */
+    pct: number;
+}
+/**
+ * One address holding part of a vault's capital — the vault contract, a custody
+ * wallet, or a bridged account on another chain.
+ */
+export interface IUntangledLocation {
+    /** Address on `chain`. Not necessarily a Stellar address (NEAR accounts appear here). */
+    address: string;
+    /** Chain slug the address lives on, e.g. `stellar`, `near`. */
+    chain: string;
+    /** Human-readable label, e.g. `idle`, `ForDefi`, `Templar`. */
+    label: string;
+    /** USD value held at this address. */
+    valueUsd: number;
+    /** ISO-8601 timestamp this location was last reconciled. */
+    asOf: string;
+}
+/**
+ * A resolved vault exposure report.
+ *
+ * Untangled answers with `{ resolved: false, reason }` and HTTP 404 for vaults
+ * it does not reconcile; `fetchUntangledVaultExposure` maps that to `null`, so
+ * `resolved` is always `true` on values that reach a caller.
+ */
+export interface IUntangledVaultExposure {
+    /** Always `true` — unresolved reports never reach callers. */
+    resolved: true;
+    /** The vault this report describes. */
+    vault: {
+        address: string;
+        chain: string;
+    };
+    /** Total USD value Untangled reconciled across every location. */
+    tvlUsd: number;
+    /** Protocol-level split of `tvlUsd`. */
+    byProtocol: IUntangledProtocolExposure[];
+    /** Asset-level split of `tvlUsd`, vault-wide. */
+    byAsset: IUntangledAssetExposure[];
+    /** Per-address drill-down of where the capital sits. */
+    locations: IUntangledLocation[];
+    /** ISO-8601 timestamp the report was assembled. */
+    asOf: string;
+    /** `true` when Untangled served a report it could not refresh in time. */
+    stale: boolean;
+}

package/lib/services/untangled/types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Response types for the Untangled portfolio API.
+ *
+ * Shape verified live on 2026-09-01 against
+ * `GET https://api-portfolio-octopos-mainnet.untangled.finance/v1/vaults/{address}/exposure`
+ * for the Gami earnUSDC Stellar vault.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/services/untangled/utils.d.ts

@@ -0,0 +1,55 @@
+import type { IDebankNormalizedResponse } from '../debank/utils';
+import type { IUntangledVaultExposure } from './types';
+/** Display metadata for an Untangled protocol slug. */
+export interface IUntangledProtocolMetadata {
+    /** Name rendered in the exposure breakdown. */
+    name: string;
+    /** Chain the protocol position lives on — not always the vault's own chain. */
+    chain: string;
+}
+/**
+ * Display metadata for the protocol slugs Untangled reports today.
+ *
+ * Untangled does not return protocol names or chains, so they are mapped here.
+ * Unknown slugs fall back to a capitalized slug on the vault's chain rather than
+ * being dropped, so a newly integrated protocol still shows up (unlabelled)
+ * instead of silently vanishing from the breakdown.
+ */
+export declare const UNTANGLED_PROTOCOL_REGISTRY: Record<string, IUntangledProtocolMetadata>;
+/**
+ * Transform an Untangled vault exposure report into the DeBank-normalized shape
+ * that `parseVaultLevelDebank` and `parseLoanLevelDebank` consume.
+ *
+ * This is the Stellar equivalent of `transformOctavfiToDebank`: a foreign
+ * portfolio shape is mapped onto the one normalized structure the vault
+ * allocation parser understands, so Stellar vaults populate the same
+ * `exposurePerCategory` / `protocolExposure` / `tokenExposure` outputs as EVM
+ * vaults with no parser changes.
+ *
+ * Mapping:
+ * - Each `byProtocol` entry becomes one position with a single supplying token,
+ *   valued in USD (`price: 1`), on the chain from
+ *   {@link UNTANGLED_PROTOCOL_REGISTRY}.
+ * - `stellar-wallet` and `upshift` are summed into one wallet token, because
+ *   both are undeployed capital rather than protocol exposure.
+ * - Dust is left in place: `filterOutBySize` in the parser applies the same
+ *   threshold Stellar and EVM vaults share.
+ *
+ * `locations`, `asOf`, `stale` and `tvlUsd` are not consumed — TVL already comes
+ * from `getVaultTvl`, and freshness is not yet surfaced on `IVaultAllocations`.
+ *
+ * @param exposure - A resolved Untangled report, or `null`/`undefined` when the
+ *   fetch failed.
+ * @returns A DeBank-normalized response. Empty positions and tokens when
+ *   `exposure` is absent, so callers can pass a failed fetch straight through.
+ *
+ * @example
+ * ```typescript
+ * const exposure = await fetchUntangledVaultExposure(vault);
+ * const normalized = transformUntangledToDebank(exposure);
+ * parseVaultLevelDebank(
+ *   normalized, protocolExposure, tokenExposure, vault, exposurePerCategory, netValue,
+ * );
+ * ```
+ */
+export declare function transformUntangledToDebank(exposure: IUntangledVaultExposure | null | undefined): IDebankNormalizedResponse;