@xoxno/sdk-js 1.0.229 → 1.0.231

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

@@ -62,7 +62,7 @@ export declare const STELLAR_NETWORKS: {
         readonly lendingPool: "CBSGF6QOQAMPFBEVSYPEQHSZRIHJ6RCGUPCRDMUX36DEKRWFAO2PZB5A";
         readonly aggregatorRouter: "CDNTWMWW2WGYTKIZTJYNGNVQQZI4KTC5BQRZ3275KESRX5T4O3AYECL5";
         readonly governance: "CDS33JDOYH3F3FL4QUQ6DV4WKHML2AKHF4LADTZ57FRUAEBTE7NMY5FQ";
-        readonly priceAggregator: "CAALOOTIDXCX7D7FMQIBSSAJLPKOM3GMXS4UUSTDIG42JCRRJHOPUHOP";
+        readonly priceAggregator: "CBMARXSYE56NPDLX42TTICM5GS5XQCYRD5VMCJME624TS6C2S53VETYU";
         readonly positionNftContract: "CDVN5JU675MEDPVRPCYC45AHFC275UH57WEU5OTFE4WFGZBNN7HTLPSY";
     };
 };
@@ -97,7 +97,7 @@ export declare const stellarNetworks: {
         readonly lendingPool: "CBSGF6QOQAMPFBEVSYPEQHSZRIHJ6RCGUPCRDMUX36DEKRWFAO2PZB5A";
         readonly aggregatorRouter: "CDNTWMWW2WGYTKIZTJYNGNVQQZI4KTC5BQRZ3275KESRX5T4O3AYECL5";
         readonly governance: "CDS33JDOYH3F3FL4QUQ6DV4WKHML2AKHF4LADTZ57FRUAEBTE7NMY5FQ";
-        readonly priceAggregator: "CAALOOTIDXCX7D7FMQIBSSAJLPKOM3GMXS4UUSTDIG42JCRRJHOPUHOP";
+        readonly priceAggregator: "CBMARXSYE56NPDLX42TTICM5GS5XQCYRD5VMCJME624TS6C2S53VETYU";
         readonly positionNftContract: "CDVN5JU675MEDPVRPCYC45AHFC275UH57WEU5OTFE4WFGZBNN7HTLPSY";
     };
 };

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

@@ -2,10 +2,9 @@
  * Decoders for the Stellar lending `#[contractevent]`s (controller, pool, and
  * the price-aggregator's `config:asset_oracle`).
  *
- * Decodes core protocol topics plus pool `strategy:fee` and live controller
- * config topics used by the indexer. Intentional omissions still return
- * `null`: `config:spoke_asset` / `config:remove_spoke_asset` / `config:hub` /
- * `strategy:blend_migration` (handled by az-functions own decoders).
+ * Decodes every topic the controller, pool, price aggregator, governance and
+ * DeFindex strategy contracts emit, plus legacy keys for historical ledgers.
+ * Unknown topics (for example access-control events) return `null`.
  *
  * The public API takes base64-XDR strings (`decodeStellarLendingEvent(topicsB64,
  * dataB64)`) and parses them with this SDK's bundled `@stellar/stellar-sdk`, so
@@ -37,8 +36,7 @@ export declare const toBase64Xdr: (scv: {
 }) => 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. See the module header for the intentional
- * omissions. */
+/** Topic keys this SDK can decode. */
 export declare const STELLAR_LENDING_TOPICS: readonly string[];
 /**
  * Decode a Stellar lending controller event from its base64-XDR topics and

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

@@ -25,3 +25,4 @@ export * from './cctp.js';
 export * from './math/index.js';
 export type { StellarStrategySwapInput, StellarStrategySwapPathInput, StellarStrategySwapHopInput, } from './scval-encode.js';
 export { mapSorobanError } from '../../utils/soroban-errors.js';
+export type { MapSorobanErrorOptions } from '../../utils/soroban-errors.js';

package/dist/cjs/sdk/stellar/lending-read.d.ts

@@ -1,8 +1,9 @@
 /** Typed Stellar lending reads. Configure the API deployment with XOXNOClient.apiUrl.
  * These cached HTTP reads do not simulate transactions or authorize spending.
  */
-import type { OurRequestInit, XOXNOClient } from '../../utils/api.js';
+import { type OurRequestInit, type XOXNOClient } from '../../utils/api.js';
 import type * as Api from './lending-api-types.js';
+import type { UserTokenInventoryResponseDto } from '@xoxno/types';
 import type { StellarLendingMarketSide, StellarLendingHoldersSide, StellarMarketGraphQuery, StellarReservesParams, StellarActivityQuery, StellarActivityPageQuery, StellarGovernanceQuery, StellarPositionsQuery, StellarRevenueQuery, StellarFeeRevenueQuery, StellarParticipantsQuery, StellarLiquidationsQuery, StellarLiquidationsLeaderboardQuery, StellarVolumeQuery, StellarDistributionQuery, StellarRateSpreadQuery } from './lending-read-types.js';
 /** Load assets, hubs, spokes, reserves and keyed reserve details in one response.
  * @category Stellar lending reads
@@ -56,7 +57,18 @@ export declare const getStellarUserPositions: (client: XOXNOClient, owner: strin
  * @category Stellar lending reads
  */
 export declare const getStellarAccountPositions: (client: XOXNOClient, accountId: string, init?: OurRequestInit) => Promise<Api.AccountPositionsDto>;
-/** Read exact token base-unit holdings for a G or C wallet. Holdings may exceed spendable funds. Requires the API release exposing this route; older deployments return 404.
+/** Read a G or C wallet's token holdings from `/user/{owner}/token-inventory`:
+ * Horizon balances (native XLM and classic assets, keyed by their SAC id) plus
+ * indexed Soroban tokens, cached for about 10 seconds. Each token's
+ * `identifier` is its contract id and `balance` is base units as a decimal
+ * string. Tokens without a balance or trustline are absent.
+ * @category Stellar lending reads
+ */
+export declare const getStellarWalletTokens: (client: XOXNOClient, owner: string, init?: OurRequestInit) => Promise<UserTokenInventoryResponseDto>;
+/** Read exact token base-unit holdings of one asset for a G or C wallet, from
+ * {@link getStellarWalletTokens}. An asset the wallet does not hold returns
+ * `amount: '0'`, with decimals read from the lending asset. Holdings may exceed
+ * spendable funds (reserves, liabilities).
  * @category Stellar lending reads
  */
 export declare const getStellarWalletBalance: (client: XOXNOClient, owner: string, asset: string, init?: OurRequestInit) => Promise<Api.StellarWalletBalanceDto>;
@@ -218,6 +230,8 @@ export declare const stellarLendingRead: (client: XOXNOClient) => {
     userPositions: (owner: string, init?: OurRequestInit) => Promise<Api.AccountPositionsDto>;
     /** {@inheritDoc getStellarAccountPositions} */
     accountPositions: (accountId: string, init?: OurRequestInit) => Promise<Api.AccountPositionsDto>;
+    /** {@inheritDoc getStellarWalletTokens} */
+    walletTokens: (owner: string, init?: OurRequestInit) => Promise<UserTokenInventoryResponseDto>;
     /** {@inheritDoc getStellarWalletBalance} */
     walletBalance: (owner: string, asset: string, init?: OurRequestInit) => Promise<Api.StellarWalletBalanceDto>;
     /** {@inheritDoc getStellarAssetPage} */

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

@@ -299,6 +299,40 @@ export declare function buildStellarLiquidateTx(opts: StellarLendingBuilderOptio
  * `decodeStellarLendingEvent`. Hold a parsed ScVal? Pass `toBase64Xdr(scv)`.
  */
 export declare function decodeStellarLiquidateReturn(returnValueB64: string): string;
+/**
+ * get_liquidation_estimate(account_id: u64, debt_payments: Vec<(HubAssetKey, i128)>,
+ *                          seize_mode: SeizeMode) -> LiquidationEstimate
+ *
+ * Read-only view: simulate the built transaction (`server.simulateTransaction`)
+ * and decode `result.retval` with `decodeStellarLiquidationEstimate`. Takes the
+ * same args as `buildStellarLiquidateTx`, so an estimate and the real call stay
+ * encoded identically. Never submit this transaction.
+ * @param opts - Network, caller (any account; it is only the simulation source), sequence and controller.
+ * @param args - The liquidation you intend to send.
+ * @returns Unsigned XDR to simulate.
+ * @category Lending transactions
+ */
+export declare function buildStellarLiquidationEstimateTx(opts: StellarLendingBuilderOptions, args: StellarLiquidateArgs): BuiltStellarTx;
+/** One `PaymentTuple`: a token amount without a hub id. */
+export interface StellarPaymentTuple {
+    asset: string;
+    /** Token base units for Transfer legs; RAY-scaled supply shares for Credit seizure. */
+    amount: string;
+}
+/** Decoded `LiquidationEstimate`; i128 fields as decimal strings. */
+export interface StellarLiquidationEstimate {
+    seizedCollaterals: StellarPaymentTuple[];
+    protocolFees: StellarPaymentTuple[];
+    refunds: StellarPaymentTuple[];
+    maxPaymentWad: string;
+    bonusRateBps: string;
+}
+/**
+ * Decode `get_liquidation_estimate`'s return value from base64 XDR (Soroban
+ * RPC `result.retval`). Tuples carry token addresses without hub ids; match
+ * them to the target's `(hub_id, asset)` positions yourself.
+ */
+export declare function decodeStellarLiquidationEstimate(returnValueB64: string): StellarLiquidationEstimate;
 /**
  * flash_loan(caller, asset: HubAssetKey, amount: i128, receiver, data: Bytes)
  * @param opts - Network, caller, current source sequence and deployment addresses.

package/dist/cjs/utils/soroban-errors.d.ts

@@ -1,10 +1,27 @@
+export interface MapSorobanErrorOptions {
+    /**
+     * Accept only an error emitted by one of these contract IDs (`C…`), for
+     * example the lending controller and pool. The emitter is read from the
+     * diagnostic event log, or from the `[xoxno-invoked:<id>]` tag that
+     * `prepareStellarTxXdr` adds when the string has no event log.
+     *
+     * RPC simulation errors usually carry only the top-level code
+     * (`HostError: Error(Contract, #N)`). With only the tag, a code raised by a
+     * nested contract (for example the swap aggregator) cannot be told apart;
+     * read the simulation's diagnostic events when that matters.
+     */
+    contracts?: readonly string[];
+}
 /**
  * Extracts a `Error(Contract, #N)` code from a raw Soroban simulation/RPC error
  * string and resolves it against the rs-lending-xlm catalog. Matches only the
  * exact `Error(Contract, #N)` pattern — never loose digits, since raw error
  * strings can contain unrelated numbers (fees, ledgers, sequence numbers).
+ *
+ * Without `opts.contracts` it maps the first code in the string, whichever
+ * contract emitted it.
  */
-export declare function mapSorobanError(raw: string): {
+export declare function mapSorobanError(raw: string, opts?: MapSorobanErrorOptions): {
     code: number;
     name: string;
     message: string;

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

@@ -32,7 +32,7 @@
         lendingPool: 'CBSGF6QOQAMPFBEVSYPEQHSZRIHJ6RCGUPCRDMUX36DEKRWFAO2PZB5A',
         aggregatorRouter: 'CDNTWMWW2WGYTKIZTJYNGNVQQZI4KTC5BQRZ3275KESRX5T4O3AYECL5',
         governance: 'CDS33JDOYH3F3FL4QUQ6DV4WKHML2AKHF4LADTZ57FRUAEBTE7NMY5FQ',
-        priceAggregator: 'CAALOOTIDXCX7D7FMQIBSSAJLPKOM3GMXS4UUSTDIG42JCRRJHOPUHOP',
+        priceAggregator: 'CBMARXSYE56NPDLX42TTICM5GS5XQCYRD5VMCJME624TS6C2S53VETYU',
         positionNftContract: 'CDVN5JU675MEDPVRPCYC45AHFC275UH57WEU5OTFE4WFGZBNN7HTLPSY'
     }
 };

package/dist/esm/sdk/stellar/events/decode.js

@@ -2,10 +2,9 @@
  * Decoders for the Stellar lending `#[contractevent]`s (controller, pool, and
  * the price-aggregator's `config:asset_oracle`).
  *
- * Decodes core protocol topics plus pool `strategy:fee` and live controller
- * config topics used by the indexer. Intentional omissions still return
- * `null`: `config:spoke_asset` / `config:remove_spoke_asset` / `config:hub` /
- * `strategy:blend_migration` (handled by az-functions own decoders).
+ * Decodes every topic the controller, pool, price aggregator, governance and
+ * DeFindex strategy contracts emit, plus legacy keys for historical ledgers.
+ * Unknown topics (for example access-control events) return `null`.
  *
  * The public API takes base64-XDR strings (`decodeStellarLendingEvent(topicsB64,
  * dataB64)`) and parses them with this SDK's bundled `@stellar/stellar-sdk`, so
@@ -70,7 +69,8 @@ const POSITION_MODE = [
     'close_wd',
     'migrate',
     'rp_col_net',
-    'liq_credit'
+    'liq_credit',
+    'flash_pos'
 ];
 const positionMode = (v)=>POSITION_MODE[num(v)] ?? 'None';
 // Unknown discriminants surface as their decimal string instead of throwing.
@@ -195,9 +195,11 @@ const REGISTRY = {
                 marketAddress: str(d.market_address)
             }
         }),
+    // `hub_id` tells same-token markets apart; absent on pre-hub ledgers.
     'market:params_update': (d)=>({
             topic: 'market:params_update',
             data: {
+                hubId: d.hub_id === undefined ? undefined : num(d.hub_id),
                 asset: str(d.asset),
                 maxBorrowRateRay: dec(d.max_borrow_rate),
                 baseBorrowRateRay: dec(d.base_borrow_rate),
@@ -303,12 +305,14 @@ const REGISTRY = {
                 totalCollateralUsdWad: dec(d.total_collateral_usd_wad)
             }
         }),
+    // Current contracts emit `{ token, amount, account_id }`; `usd_value_wad`
+    // exists only on older ledgers and is never fabricated.
     'strategy:initial_payment': (d)=>({
             topic: 'strategy:initial_payment',
             data: {
                 token: str(d.token),
                 amount: dec(d.amount),
-                usdValueWad: dec(d.usd_value_wad),
+                usdValueWad: d.usd_value_wad === undefined ? undefined : dec(d.usd_value_wad),
                 accountId: dec(d.account_id)
             }
         }),
@@ -397,10 +401,112 @@ const REGISTRY = {
                 liquidationBonusFactorBps: num(s.liquidation_bonus_factor_bps)
             }
         };
-    }
+    },
+    'position:flash_position': (d)=>({
+            topic: 'position:flash_position',
+            data: {
+                accountId: dec(d.account_id),
+                hubId: num(d.hub_id),
+                asset: str(d.asset),
+                receiver: str(d.receiver),
+                caller: str(d.caller),
+                amount: dec(d.amount),
+                amountReceived: dec(d.amount_received),
+                fee: dec(d.fee)
+            }
+        }),
+    'revenue:claim': (d)=>({
+            topic: 'revenue:claim',
+            data: {
+                hubId: num(d.hub_id),
+                asset: str(d.asset),
+                caller: str(d.caller),
+                accumulator: str(d.accumulator),
+                amount: dec(d.amount)
+            }
+        }),
+    'account:delegate': (d)=>({
+            topic: 'account:delegate',
+            data: {
+                accountId: dec(d.account_id),
+                owner: str(d.owner),
+                delegate: str(d.delegate),
+                granted: Boolean(d.granted)
+            }
+        }),
+    'config:hub': (d)=>({
+            topic: 'config:hub',
+            data: {
+                hubId: num(d.hub_id)
+            }
+        }),
+    'config:spoke_asset': (d)=>{
+        const c = d.config;
+        return {
+            topic: 'config:spoke_asset',
+            data: {
+                spokeId: num(d.spoke_id),
+                hubId: num(d.hub_id),
+                asset: str(d.asset),
+                config: {
+                    isCollateralizable: Boolean(c.is_collateralizable),
+                    isBorrowable: Boolean(c.is_borrowable),
+                    paused: Boolean(c.paused),
+                    frozen: Boolean(c.frozen),
+                    noSeize: Boolean(c.no_seize),
+                    loanToValueBps: num(c.loan_to_value),
+                    liquidationThresholdBps: num(c.liquidation_threshold),
+                    liquidationBonusBps: num(c.liquidation_bonus),
+                    liquidationFeesBps: num(c.liquidation_fees),
+                    supplyCap: dec(c.supply_cap),
+                    borrowCap: dec(c.borrow_cap)
+                }
+            }
+        };
+    },
+    'config:remove_spoke_asset': (d)=>({
+            topic: 'config:remove_spoke_asset',
+            data: {
+                spokeId: num(d.spoke_id),
+                hubId: num(d.hub_id),
+                asset: str(d.asset)
+            }
+        }),
+    'strategy:blend_migration': (d)=>({
+            topic: 'strategy:blend_migration',
+            data: {
+                accountId: dec(d.account_id),
+                blendPool: str(d.blend_pool),
+                collateralCount: num(d.collateral_count),
+                supplyCount: num(d.supply_count),
+                debtCount: num(d.debt_count)
+            }
+        }),
+    // Emitted by the DeFindex strategy adapter, not the controller.
+    'strategy:harvest': (d)=>({
+            topic: 'strategy:harvest',
+            data: {
+                from: str(d.from),
+                amount: dec(d.amount),
+                pricePerShare: dec(d.price_per_share)
+            }
+        }),
+    'governance:deploy_controller': (d)=>({
+            topic: 'governance:deploy_controller',
+            data: {
+                controller: str(d.controller),
+                wasmHash: hex(d.wasm_hash)
+            }
+        }),
+    'governance:deploy_price_aggregator': (d)=>({
+            topic: 'governance:deploy_price_aggregator',
+            data: {
+                priceAggregator: str(d.price_aggregator),
+                wasmHash: hex(d.wasm_hash)
+            }
+        })
 };
-/** Topic keys this SDK can decode. See the module header for the intentional
- * omissions. */ export const STELLAR_LENDING_TOPICS = Object.freeze(Object.keys(REGISTRY));
+/** Topic keys this SDK can decode. */ export const STELLAR_LENDING_TOPICS = Object.freeze(Object.keys(REGISTRY));
 /**
  * Decode a Stellar lending controller event from its base64-XDR topics and
  * data (exactly as Soroban RPC `getEvents` delivers them). Returns `null` for a

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

@@ -1,6 +1,7 @@
 /** Typed Stellar lending reads. Configure the API deployment with XOXNOClient.apiUrl.
  * These cached HTTP reads do not simulate transactions or authorize spending.
- */ const BASE = '/stellar-lending';
+ */ import { Chain } from "../../utils/api.js";
+const BASE = '/stellar-lending';
 const enc = encodeURIComponent;
 /** Load assets, hubs, spokes, reserves and keyed reserve details in one response.
  * @category Stellar lending reads
@@ -46,9 +47,43 @@ const enc = encodeURIComponent;
 /** Read a single lending account, identified by its decimal ID; balances use RAY token quantities.
  * @category Stellar lending reads
  */ export const getStellarAccountPositions = (client, accountId, init)=>client.fetchWithTimeout(`${BASE}/accounts/${enc(accountId)}/positions`, init);
-/** Read exact token base-unit holdings for a G or C wallet. Holdings may exceed spendable funds. Requires the API release exposing this route; older deployments return 404.
- * @category Stellar lending reads
- */ export const getStellarWalletBalance = (client, owner, asset, init)=>client.fetchWithTimeout(`${BASE}/users/${enc(owner)}/assets/${enc(asset)}/balance`, init);
+/** Read a G or C wallet's token holdings from `/user/{owner}/token-inventory`:
+ * Horizon balances (native XLM and classic assets, keyed by their SAC id) plus
+ * indexed Soroban tokens, cached for about 10 seconds. Each token's
+ * `identifier` is its contract id and `balance` is base units as a decimal
+ * string. Tokens without a balance or trustline are absent.
+ * @category Stellar lending reads
+ */ export const getStellarWalletTokens = (client, owner, init)=>client.fetchWithTimeout(`/user/${enc(owner)}/token-inventory`, init);
+/** Read exact token base-unit holdings of one asset for a G or C wallet, from
+ * {@link getStellarWalletTokens}. An asset the wallet does not hold returns
+ * `amount: '0'`, with decimals read from the lending asset. Holdings may exceed
+ * spendable funds (reserves, liabilities).
+ * @category Stellar lending reads
+ */ export const getStellarWalletBalance = async (client, owner, asset, init)=>{
+    const inventory = await getStellarWalletTokens(client, owner, init);
+    const network = client.chain === Chain.MAINNET ? 'mainnet' : 'testnet';
+    const token = (inventory?.tokens ?? []).find((t)=>t.identifier === asset);
+    if (token) {
+        return {
+            owner,
+            network: token.stellarNetwork ?? network,
+            asset,
+            amount: String(token.balance),
+            decimals: token.decimals
+        };
+    }
+    const { decimals } = await getStellarAsset(client, asset, init);
+    if (typeof decimals !== 'number') {
+        throw new Error(`Stellar lending: no decimals for ${asset}; it is not a lending asset`);
+    }
+    return {
+        owner,
+        network,
+        asset,
+        amount: '0',
+        decimals
+    };
+};
 /** Load overview, deposit/borrow markets and chart series for an asset page.
  * @category Stellar lending reads
  */ export const getStellarAssetPage = (client, asset, query, init)=>client.fetchWithTimeout(`${BASE}/assets/${enc(asset)}/page`, {
@@ -307,6 +342,7 @@ const enc = encodeURIComponent;
         /** {@inheritDoc getStellarSpoke} */ spoke: (spokeId, init)=>getStellarSpoke(client, spokeId, init),
         /** {@inheritDoc getStellarUserPositions} */ userPositions: (owner, init)=>getStellarUserPositions(client, owner, init),
         /** {@inheritDoc getStellarAccountPositions} */ accountPositions: (accountId, init)=>getStellarAccountPositions(client, accountId, init),
+        /** {@inheritDoc getStellarWalletTokens} */ walletTokens: (owner, init)=>getStellarWalletTokens(client, owner, init),
         /** {@inheritDoc getStellarWalletBalance} */ walletBalance: (owner, asset, init)=>getStellarWalletBalance(client, owner, asset, init),
         /** {@inheritDoc getStellarAssetPage} */ assetPage: (asset, query, init)=>getStellarAssetPage(client, asset, query, init),
         /** {@inheritDoc getStellarAssetMarkets} */ assetMarkets: (asset, side, init)=>getStellarAssetMarkets(client, asset, side, init),

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

@@ -248,6 +248,51 @@ function encodeSpokeId(value) {
     }
     throw new Error(`Stellar builder: liquidate return value must be a u64, got ${typeof native}`);
 }
+/**
+ * get_liquidation_estimate(account_id: u64, debt_payments: Vec<(HubAssetKey, i128)>,
+ *                          seize_mode: SeizeMode) -> LiquidationEstimate
+ *
+ * Read-only view: simulate the built transaction (`server.simulateTransaction`)
+ * and decode `result.retval` with `decodeStellarLiquidationEstimate`. Takes the
+ * same args as `buildStellarLiquidateTx`, so an estimate and the real call stay
+ * encoded identically. Never submit this transaction.
+ * @param opts - Network, caller (any account; it is only the simulation source), sequence and controller.
+ * @param args - The liquidation you intend to send.
+ * @returns Unsigned XDR to simulate.
+ * @category Lending transactions
+ */ export function buildStellarLiquidationEstimateTx(opts, args) {
+    return buildTx(opts, 'get_liquidation_estimate', [
+        u64(args.accountNonce),
+        tupleHubAssetAmountVec([
+            ...args.debtPayments
+        ]),
+        seizeMode(args.seizeMode ?? 'Transfer')
+    ]);
+}
+const paymentTuples = (v)=>(Array.isArray(v) ? v : []).map((p)=>{
+        const row = p;
+        return {
+            asset: String(row.asset),
+            amount: String(row.amount)
+        };
+    });
+/**
+ * Decode `get_liquidation_estimate`'s return value from base64 XDR (Soroban
+ * RPC `result.retval`). Tuples carry token addresses without hub ids; match
+ * them to the target's `(hub_id, asset)` positions yourself.
+ */ export function decodeStellarLiquidationEstimate(returnValueB64) {
+    const native = scValToNative(xdr.ScVal.fromXDR(returnValueB64, 'base64'));
+    if (!native || typeof native !== 'object' || Array.isArray(native)) {
+        throw new Error('Stellar builder: liquidation estimate must be a struct');
+    }
+    return {
+        seizedCollaterals: paymentTuples(native.seized_collaterals),
+        protocolFees: paymentTuples(native.protocol_fees),
+        refunds: paymentTuples(native.refunds),
+        maxPaymentWad: String(native.max_payment_wad),
+        bonusRateBps: String(native.bonus_rate_bps)
+    };
+}
 /**
  * flash_loan(caller, asset: HubAssetKey, amount: i128, receiver, data: Bytes)
  * @param opts - Network, caller, current source sequence and deployment addresses.