upshift-finance 1.0.0

package/lib/adapters/stellar/getters.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Stellar Vault Getters
+ *
+ * Data fetching for Stellar vaults. Enriches backend metadata with on-chain
+ * total assets, total supply, and share decimals from Soroban RPC. Also
+ * provides user position queries and deposit preview (convertToShares).
+ * Falls back to backend TVL for total assets, zero for total supply, and
+ * STELLAR_FALLBACK_DECIMALS for share decimals when on-chain queries fail.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToShares = exports.getStellarUserPosition = exports.getStellarVault = void 0;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const core_1 = require("../../core");
+const utils_1 = require("../../modules/vaults/utils");
+const constants_1 = require("./constants");
+const soroban_1 = require("./soroban");
+/**
+ * Parse an ScVal into a share-decimals value, reporting whether the
+ * authoritative on-chain value was available.
+ *
+ * Returns `{ decimals, fromFallback }`. When the `decimals()` retval is missing
+ * or unparseable, `decimals` is STELLAR_FALLBACK_DECIMALS (7) and `fromFallback`
+ * is `true` — the signal callers need to avoid trusting a fabricated scale (a
+ * silent 7 under-redeems ERC4626 offset vaults; see AUGUST-6381). A successful
+ * parse returns the on-chain value with `fromFallback: false`.
+ */
+function parseDecimals(scVal, context, vaultAddress) {
+    if (!scVal) {
+        core_1.Logger.log.error(context, 'Decimals not available — using fallback (financial values may be incorrect)', {
+            vault: vaultAddress,
+            fallbackDecimals: constants_1.STELLAR_FALLBACK_DECIMALS,
+        });
+        return { decimals: constants_1.STELLAR_FALLBACK_DECIMALS, fromFallback: true };
+    }
+    try {
+        return { decimals: Number((0, stellar_sdk_1.scValToBigInt)(scVal)), fromFallback: false };
+    }
+    catch (parseErr) {
+        core_1.Logger.log.error(context, 'Failed to parse decimals from Soroban — using fallback (financial values may be incorrect)', {
+            vault: vaultAddress,
+            fallbackDecimals: constants_1.STELLAR_FALLBACK_DECIMALS,
+            error: String(parseErr),
+        });
+        return { decimals: constants_1.STELLAR_FALLBACK_DECIMALS, fromFallback: true };
+    }
+}
+/**
+ * Parse an ScVal into a decimals number, returning the fallback on failure.
+ * Thin wrapper over {@link parseDecimals} for callers that only need the value
+ * (the fallback is already surfaced via logs). Prefer `parseDecimals` when the
+ * caller must distinguish a fallback from an authoritative read.
+ */
+function parseDecimalsOrFallback(scVal, context, vaultAddress) {
+    return parseDecimals(scVal, context, vaultAddress).decimals;
+}
+/**
+ * Resolve the Stellar network for a vault from its backend metadata.
+ * Logs a warning when falling back to mainnet.
+ */
+function resolveNetwork(tokenizedVault) {
+    const meta = tokenizedVault.stellar_vault_metadata;
+    const networkName = meta?.network_name;
+    if (networkName === 'testnet' || networkName === 'mainnet') {
+        return networkName;
+    }
+    if (networkName) {
+        core_1.Logger.log.warn('resolveNetwork', `Unrecognized network "${networkName}", falling back to mainnet`, { vault: tokenizedVault.address });
+    }
+    else {
+        core_1.Logger.log.warn('resolveNetwork', 'No network_name in vault metadata — defaulting to mainnet', { vault: tokenizedVault.address });
+    }
+    return 'mainnet';
+}
+/**
+ * Build a unified IVault from backend + on-chain data for Stellar vaults.
+ * Reads total assets and total supply from the Soroban contract via RPC.
+ * Falls back to backend `latest_reported_tvl` for total assets, or zero
+ * for total supply, when on-chain queries fail.
+ */
+const getStellarVault = async (tokenizedVault, options) => {
+    const stellarMetadata = tokenizedVault.stellar_vault_metadata;
+    const depositDecimals = stellarMetadata?.deposit_token_decimals ?? constants_1.STELLAR_FALLBACK_DECIMALS;
+    if (stellarMetadata?.deposit_token_decimals == null) {
+        core_1.Logger.log.warn('getStellarVault', 'Using fallback decimals — TVL may be incorrect if deposit token is not 7 decimals', {
+            vault: tokenizedVault.address,
+            depositToken: stellarMetadata?.deposit_token_address ?? 'UNKNOWN',
+            STELLAR_FALLBACK_DECIMALS: constants_1.STELLAR_FALLBACK_DECIMALS,
+        });
+    }
+    // Attempt on-chain queries for total assets, total supply, and share decimals
+    const network = resolveNetwork(tokenizedVault);
+    // Only apply the configured RPC override when it matches this vault's network
+    // (a testnet override must not be used for a mainnet read). `options` may be
+    // omitted by JS callers, so guard it.
+    const overrideRpcUrl = options?.stellarRpc?.network === network
+        ? options.stellarRpc.rpcUrl
+        : undefined;
+    const config = (0, soroban_1.resolveNetworkConfig)(network, overrideRpcUrl);
+    const [assetsResult, supplyResult, decimalsResult] = await Promise.all([
+        (0, soroban_1.queryContract)(config, tokenizedVault.address, 'total_assets'),
+        (0, soroban_1.queryContract)(config, tokenizedVault.address, 'total_supply'),
+        (0, soroban_1.queryContract)(config, tokenizedVault.address, 'decimals'),
+    ]);
+    // Share token decimals may differ from deposit token decimals
+    const shareDecimals = parseDecimalsOrFallback(decimalsResult, 'getStellarVault', tokenizedVault.address);
+    let totalAssets;
+    if (assetsResult) {
+        try {
+            const rawAssets = (0, stellar_sdk_1.scValToBigInt)(assetsResult);
+            totalAssets = (0, core_1.toNormalizedBn)(rawAssets, depositDecimals);
+        }
+        catch (parseErr) {
+            core_1.Logger.log.warn('getStellarVault', 'Failed to parse total_assets from Soroban — falling back to backend TVL', { vault: tokenizedVault.address, error: String(parseErr) });
+            totalAssets = (0, utils_1.backendTvlToNormalizedBn)(tokenizedVault.latest_reported_tvl, depositDecimals);
+        }
+    }
+    else {
+        core_1.Logger.log.warn('getStellarVault', 'Could not fetch total_assets from Soroban — falling back to backend TVL', { vault: tokenizedVault.address });
+        totalAssets = (0, utils_1.backendTvlToNormalizedBn)(tokenizedVault.latest_reported_tvl, depositDecimals);
+    }
+    let totalSupply = (0, core_1.toNormalizedBn)(0, shareDecimals);
+    if (supplyResult) {
+        try {
+            const rawSupply = (0, stellar_sdk_1.scValToBigInt)(supplyResult);
+            totalSupply = (0, core_1.toNormalizedBn)(rawSupply, shareDecimals);
+        }
+        catch (parseErr) {
+            core_1.Logger.log.warn('getStellarVault', 'Failed to parse total_supply from Soroban', { vault: tokenizedVault.address, error: String(parseErr) });
+        }
+    }
+    else {
+        core_1.Logger.log.warn('getStellarVault', 'Could not fetch total_supply from Soroban — falling back to 0', { vault: tokenizedVault.address });
+    }
+    const depositAsset = {
+        address: stellarMetadata?.deposit_token_address ?? '',
+        symbol: stellarMetadata?.deposit_token_symbol ?? 'UNKNOWN',
+        decimals: depositDecimals,
+    };
+    const isDepositPaused = !depositAsset.address;
+    if (isDepositPaused) {
+        core_1.Logger.log.warn('getStellarVault', 'Missing deposit asset address — vault will be marked as deposit-paused', { vault: tokenizedVault.address });
+    }
+    return (0, utils_1.buildBackendVault)(tokenizedVault, {
+        isDepositPaused,
+        chainId: constants_1.STELLAR_CHAIN_ID,
+        version: 'stellar-0',
+        name: tokenizedVault.vault_name || 'Stellar Vault',
+        totalAssets,
+        totalSupply,
+        depositAssets: [depositAsset],
+        receipt: {
+            address: tokenizedVault.address,
+            symbol: tokenizedVault.receipt_token_symbol || 'UNKNOWN',
+            decimals: shareDecimals,
+        },
+    });
+};
+exports.getStellarVault = getStellarVault;
+/**
+ * Get user position for a Stellar vault.
+ * Queries the vault contract's balance(address) and decimals() functions via Soroban RPC.
+ *
+ * Returns `{ shares, decimals, decimalsFromFallback }` on success (shares may be
+ * '0' for zero balance), or null when the balance query fails. The two reads are
+ * independent: a `decimals()` failure does NOT null the result — instead
+ * `decimals` falls back to STELLAR_FALLBACK_DECIMALS (7) and
+ * `decimalsFromFallback` is set to `true` so callers can tell a fabricated 7
+ * apart from a genuine 7-decimal vault.
+ *
+ * Why this matters: an ERC4626 offset vault has share decimals = asset + offset
+ * (e.g. 13). A consumer that sizes a redeem trusting a silent fallback 7 would
+ * under-redeem by `10^offset`. Callers that settle a redeem from this position
+ * MUST refuse (surface an error) when `decimalsFromFallback` is `true` rather
+ * than trusting `decimals`. See AUGUST-6381 (follow-up to AUGUST-6380).
+ *
+ * @param vaultAddress - Stellar vault contract ID (C… address)
+ * @param walletAddress - User's Stellar account (G… address); validated upfront
+ * @param network - 'mainnet' | 'testnet' (defaults to 'mainnet')
+ * @param sorobanRpcUrl - Optional override Soroban RPC endpoint (e.g. a keyed
+ *   Alchemy URL); becomes the primary with the SDK's public endpoints kept as
+ *   failover. Omit to use the public endpoints.
+ * @returns The position, or `null` if the balance read failed or was unparseable.
+ * @throws AugustValidationError on an invalid `walletAddress`.
+ * @example
+ * ```ts
+ * const pos = await getStellarUserPosition(vault, wallet, 'mainnet');
+ * if (!pos || pos.decimalsFromFallback) {
+ *   // Refuse to size a redeem — share scale is not authoritatively known.
+ *   throw new Error('Stellar share decimals unresolved');
+ * }
+ * const human = Number(pos.shares) / 10 ** pos.decimals;
+ * ```
+ */
+const getStellarUserPosition = async (vaultAddress, walletAddress, network = 'mainnet', sorobanRpcUrl) => {
+    const config = (0, soroban_1.resolveNetworkConfig)(network, sorobanRpcUrl);
+    // Validate address upfront — invalid input is a caller bug, not an RPC issue
+    let userAddress;
+    try {
+        userAddress = new stellar_sdk_1.Address(walletAddress);
+    }
+    catch (addrErr) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `getStellarUserPosition: invalid walletAddress "${walletAddress}": ${String(addrErr)}`, { cause: addrErr });
+    }
+    try {
+        // Fetch balance and decimals in parallel — they're independent queries
+        const [balanceResult, decimalsResult] = await Promise.all([
+            (0, soroban_1.queryContract)(config, vaultAddress, 'balance', [userAddress.toScVal()]),
+            (0, soroban_1.queryContract)(config, vaultAddress, 'decimals'),
+        ]);
+        const { decimals, fromFallback: decimalsFromFallback } = parseDecimals(decimalsResult, 'getStellarUserPosition', vaultAddress);
+        if (!balanceResult) {
+            core_1.Logger.log.warn('getStellarUserPosition', 'Balance query returned null', {
+                vault: vaultAddress,
+                wallet: walletAddress,
+            });
+            return null;
+        }
+        let rawBalance;
+        try {
+            rawBalance = (0, stellar_sdk_1.scValToBigInt)(balanceResult);
+        }
+        catch (parseErr) {
+            core_1.Logger.log.error('getStellarUserPosition', 'Failed to parse balance ScVal — possible contract incompatibility', {
+                vault: vaultAddress,
+                wallet: walletAddress,
+                error: String(parseErr),
+            });
+            return null;
+        }
+        return {
+            shares: rawBalance.toString(),
+            decimals,
+            decimalsFromFallback,
+        };
+    }
+    catch (err) {
+        core_1.Logger.log.error('getStellarUserPosition', 'Unexpected error querying Stellar user position', {
+            vault: vaultAddress,
+            wallet: walletAddress,
+            error: String(err),
+        });
+        return null;
+    }
+};
+exports.getStellarUserPosition = getStellarUserPosition;
+/**
+ * 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
+ * failure.
+ *
+ * @param vaultAddress  Stellar contract ID (C… address)
+ * @param rawAmount     Deposit amount in the deposit token's smallest unit
+ * @param network       'mainnet' | 'testnet'
+ * @param sorobanRpcUrl - Optional override Soroban RPC endpoint (e.g. a keyed
+ *   Alchemy URL); becomes the primary with the SDK's public endpoints kept as
+ *   failover. Omit to use the public endpoints.
+ */
+const convertToShares = async (vaultAddress, rawAmount, network = 'mainnet', sorobanRpcUrl) => {
+    // Validate address upfront — invalid input is a caller bug, not an RPC issue
+    try {
+        new stellar_sdk_1.Address(vaultAddress);
+    }
+    catch (addrErr) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `convertToShares: invalid vaultAddress "${vaultAddress}": ${String(addrErr)}`, { cause: addrErr });
+    }
+    const config = (0, soroban_1.resolveNetworkConfig)(network, sorobanRpcUrl);
+    const amountBigInt = (0, soroban_1.toBigIntAmount)(rawAmount, 'rawAmount');
+    const amountScVal = (0, stellar_sdk_1.nativeToScVal)(amountBigInt, { type: 'i128' });
+    const result = await (0, soroban_1.queryContract)(config, vaultAddress, 'convert_to_shares', [amountScVal]);
+    if (!result) {
+        core_1.Logger.log.warn('convertToShares', 'Soroban query returned no result', {
+            vault: vaultAddress,
+            rawAmount,
+        });
+        return null;
+    }
+    try {
+        return (0, stellar_sdk_1.scValToBigInt)(result).toString();
+    }
+    catch (err) {
+        core_1.Logger.log.error('convertToShares', 'Failed to parse result — possible contract incompatibility', {
+            vault: vaultAddress,
+            error: String(err),
+        });
+        return null;
+    }
+};
+exports.convertToShares = convertToShares;
+//# sourceMappingURL=getters.js.map

package/lib/adapters/stellar/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Stellar Adapter for August SDK
+ *
+ * Provides Stellar vault operations: deposit, redeem, position queries,
+ * and on-chain data fetching via Soroban RPC.
+ *
+ * @module StellarAdapter
+ */
+import * as StellarConstants from './constants';
+import * as StellarGetters from './getters';
+import * as StellarActions from './actions';
+import * as StellarSubmit from './submit';
+import type { IStellarNetwork, IStellarDepositParams, IStellarRedeemParams, IStellarUserPosition } from './types';
+export declare const Stellar: {
+    utils: {
+        isStellarAddress: typeof import("./utils").isStellarAddress;
+        getExplorerLink: typeof import("./utils").getExplorerLink;
+        assertNotStellar: typeof import("./utils").assertNotStellar;
+    };
+    constants: typeof StellarConstants;
+    actions: typeof StellarActions;
+    submit: typeof StellarSubmit;
+    getters: typeof StellarGetters;
+};
+/**
+ * Stellar Adapter for August SDK
+ *
+ * @example
+ * ```
+ * const adapter = new StellarAdapter('testnet');
+ * const xdr = await adapter.vaultDeposit({
+ *   contractId: 'CBGWW5...',
+ *   amount: '1000000',
+ *   senderAddress: 'GDLZ...',
+ * });
+ * // Sign xdr with wallet (e.g. Freighter), then submit via adapter.submitTransaction()
+ * ```
+ */
+export declare class StellarAdapter {
+    private _network;
+    /**
+     * Optional consumer-supplied Soroban RPC endpoint (e.g. a keyed Alchemy URL).
+     * When set it is the primary, with the SDK's public endpoints as failover.
+     */
+    private _sorobanRpcUrl?;
+    /**
+     * @param network - Stellar network to operate on; defaults to `'mainnet'`.
+     * @param options - Optional adapter configuration. Its `sorobanRpcUrl` field
+     *   overrides the Soroban RPC endpoint (e.g. a keyed Alchemy URL): it becomes
+     *   the primary with the SDK's built-in public endpoints kept behind it as
+     *   failover, and a per-call `sorobanRpcUrl` (on the deposit/redeem params)
+     *   takes precedence over this adapter-level one.
+     */
+    constructor(network?: IStellarNetwork, options?: {
+        sorobanRpcUrl?: string;
+    });
+    get network(): IStellarNetwork;
+    isStellarAddress(address: string): boolean;
+    getExplorerLink(id: string, type?: 'contract' | 'account' | 'tx'): string;
+    /**
+     * Build an unsigned deposit transaction for a Stellar vault.
+     * @returns Base64-encoded XDR of the unsigned transaction.
+     */
+    vaultDeposit(params: Omit<IStellarDepositParams, 'network'>): Promise<string>;
+    /**
+     * Build an unsigned redeem transaction for a Stellar vault.
+     * @returns Base64-encoded XDR of the unsigned transaction.
+     */
+    vaultRedeem(params: Omit<IStellarRedeemParams, 'network'>): Promise<string>;
+    /**
+     * Submit a signed Soroban transaction and poll until the network confirms it.
+     *
+     * Submits on the network this adapter was constructed with, so `signedXdr`
+     * must be signed for that same network.
+     *
+     * @param signedXdr - Base64-encoded XDR of the signed transaction.
+     * @returns The transaction hash once the network confirms it as successful.
+     * @throws {@link AugustTimeoutError} when the transaction is not confirmed
+     *   within the poll budget (`MAX_POLL_ATTEMPTS`).
+     * @throws {@link AugustSDKError} when the RPC rejects the submission or the
+     *   transaction confirms as failed. Its `context` carries `{ network, status }`
+     *   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.
+     * @example
+     * ```ts
+     * try {
+     *   const hash = await adapter.submitTransaction(signedXdr);
+     * } catch (err) {
+     *   if (err instanceof AugustSDKError && err.context?.resultCode === 'txBadSeq') {
+     *     // stale sequence number — rebuild the transaction and resubmit
+     *   }
+     * }
+     * ```
+     */
+    submitTransaction(signedXdr: string): Promise<string>;
+    /**
+     * Get user's vault share balance.
+     *
+     * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
+     * if the balance read fails. When `decimalsFromFallback` is `true` the
+     * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
+     * a redeem MUST refuse rather than trust it (see AUGUST-6381).
+     */
+    getUserPosition(vaultAddress: string, walletAddress: string): Promise<IStellarUserPosition | null>;
+    /**
+     * Preview how many vault shares a deposit amount would yield.
+     * @param vaultAddress  Stellar contract ID (C… address)
+     * @param rawAmount     Deposit amount in the deposit token's smallest unit
+     * @returns Raw share amount as a string, or null if query fails.
+     */
+    convertToShares(vaultAddress: string, rawAmount: string): Promise<string | null>;
+}
+export default StellarAdapter;

package/lib/adapters/stellar/index.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Stellar Adapter for August SDK
+ *
+ * Provides Stellar vault operations: deposit, redeem, position queries,
+ * and on-chain data fetching via Soroban RPC.
+ *
+ * @module StellarAdapter
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarAdapter = exports.Stellar = void 0;
+const StellarConstants = __importStar(require("./constants"));
+const StellarGetters = __importStar(require("./getters"));
+const StellarActions = __importStar(require("./actions"));
+const StellarSubmit = __importStar(require("./submit"));
+const utils_1 = require("./utils");
+exports.Stellar = {
+    utils: utils_1.StellarUtils,
+    constants: StellarConstants,
+    actions: StellarActions,
+    submit: StellarSubmit,
+    getters: StellarGetters,
+};
+/**
+ * Stellar Adapter for August SDK
+ *
+ * @example
+ * ```
+ * const adapter = new StellarAdapter('testnet');
+ * const xdr = await adapter.vaultDeposit({
+ *   contractId: 'CBGWW5...',
+ *   amount: '1000000',
+ *   senderAddress: 'GDLZ...',
+ * });
+ * // Sign xdr with wallet (e.g. Freighter), then submit via adapter.submitTransaction()
+ * ```
+ */
+class StellarAdapter {
+    _network;
+    /**
+     * Optional consumer-supplied Soroban RPC endpoint (e.g. a keyed Alchemy URL).
+     * When set it is the primary, with the SDK's public endpoints as failover.
+     */
+    _sorobanRpcUrl;
+    /**
+     * @param network - Stellar network to operate on; defaults to `'mainnet'`.
+     * @param options - Optional adapter configuration. Its `sorobanRpcUrl` field
+     *   overrides the Soroban RPC endpoint (e.g. a keyed Alchemy URL): it becomes
+     *   the primary with the SDK's built-in public endpoints kept behind it as
+     *   failover, and a per-call `sorobanRpcUrl` (on the deposit/redeem params)
+     *   takes precedence over this adapter-level one.
+     */
+    constructor(network = 'mainnet', options) {
+        this._network = network;
+        this._sorobanRpcUrl = options?.sorobanRpcUrl;
+    }
+    get network() {
+        return this._network;
+    }
+    isStellarAddress(address) {
+        return utils_1.StellarUtils.isStellarAddress(address);
+    }
+    getExplorerLink(id, type) {
+        return utils_1.StellarUtils.getExplorerLink({ id, type, network: this._network });
+    }
+    /**
+     * Build an unsigned deposit transaction for a Stellar vault.
+     * @returns Base64-encoded XDR of the unsigned transaction.
+     */
+    async vaultDeposit(params) {
+        return StellarActions.handleStellarDeposit({
+            ...params,
+            network: this._network,
+            // A per-call override (params.sorobanRpcUrl) wins over the adapter-level one.
+            sorobanRpcUrl: params.sorobanRpcUrl ?? this._sorobanRpcUrl,
+        });
+    }
+    /**
+     * Build an unsigned redeem transaction for a Stellar vault.
+     * @returns Base64-encoded XDR of the unsigned transaction.
+     */
+    async vaultRedeem(params) {
+        return StellarActions.handleStellarRedeem({
+            ...params,
+            network: this._network,
+            // A per-call override (params.sorobanRpcUrl) wins over the adapter-level one.
+            sorobanRpcUrl: params.sorobanRpcUrl ?? this._sorobanRpcUrl,
+        });
+    }
+    /**
+     * Submit a signed Soroban transaction and poll until the network confirms it.
+     *
+     * Submits on the network this adapter was constructed with, so `signedXdr`
+     * must be signed for that same network.
+     *
+     * @param signedXdr - Base64-encoded XDR of the signed transaction.
+     * @returns The transaction hash once the network confirms it as successful.
+     * @throws {@link AugustTimeoutError} when the transaction is not confirmed
+     *   within the poll budget (`MAX_POLL_ATTEMPTS`).
+     * @throws {@link AugustSDKError} when the RPC rejects the submission or the
+     *   transaction confirms as failed. Its `context` carries `{ network, status }`
+     *   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.
+     * @example
+     * ```ts
+     * try {
+     *   const hash = await adapter.submitTransaction(signedXdr);
+     * } catch (err) {
+     *   if (err instanceof AugustSDKError && err.context?.resultCode === 'txBadSeq') {
+     *     // stale sequence number — rebuild the transaction and resubmit
+     *   }
+     * }
+     * ```
+     */
+    async submitTransaction(signedXdr) {
+        return StellarSubmit.submitStellarTransaction(signedXdr, this._network, this._sorobanRpcUrl);
+    }
+    /**
+     * Get user's vault share balance.
+     *
+     * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
+     * if the balance read fails. When `decimalsFromFallback` is `true` the
+     * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
+     * a redeem MUST refuse rather than trust it (see AUGUST-6381).
+     */
+    async getUserPosition(vaultAddress, walletAddress) {
+        return StellarGetters.getStellarUserPosition(vaultAddress, walletAddress, this._network, this._sorobanRpcUrl);
+    }
+    /**
+     * Preview how many vault shares a deposit amount would yield.
+     * @param vaultAddress  Stellar contract ID (C… address)
+     * @param rawAmount     Deposit amount in the deposit token's smallest unit
+     * @returns Raw share amount as a string, or null if query fails.
+     */
+    async convertToShares(vaultAddress, rawAmount) {
+        return StellarGetters.convertToShares(vaultAddress, rawAmount, this._network, this._sorobanRpcUrl);
+    }
+}
+exports.StellarAdapter = StellarAdapter;
+exports.default = StellarAdapter;
+//# sourceMappingURL=index.js.map