@getomnichain/omnichain 0.5.1 → 0.6.1

package/dist/cjs/stellar/stellar_chain.js

@@ -0,0 +1,1334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarChain = exports.StellarSignedMessage = void 0;
+exports.stellarMessageHash = stellarMessageHash;
+exports.scvalToUint32 = scvalToUint32;
+exports.scvalToUtf8String = scvalToUtf8String;
+exports.scvalToInt128 = scvalToInt128;
+const node_crypto_1 = require("node:crypto");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const decimal_js_1 = require("decimal.js");
+const abstract_gas_pricing_ts_1 = require("../abstract_gas_pricing.js");
+const asset_map_ts_1 = require("../asset_map.js");
+const bytes_from_hex_ts_1 = require("../bytes_from_hex.js");
+const chain_base_ts_1 = require("../chain.base.js");
+const chain_type_ts_1 = require("../chain_type.js");
+const errors_ts_1 = require("../errors.js");
+const python_builtins_ts_1 = require("../python_builtins.js");
+const python_repr_ts_1 = require("../python_repr.js");
+const python_pydantic_ts_1 = require("../python_pydantic.js");
+const network_type_ts_1 = require("../network_type.js");
+const priority_ts_1 = require("../priority.js");
+const transaction_json_ts_1 = require("../transaction_json.js");
+const transaction_prerequisite_ts_1 = require("../transaction_prerequisite.js");
+const transaction_simulation_ts_1 = require("../transaction_simulation.js");
+const transaction_status_ts_1 = require("../transaction_status.js");
+const wallet_base_ts_1 = require("../wallet.base.js");
+const stellar_asset_ts_1 = require("./stellar_asset.js");
+const stellar_gas_pricing_ts_1 = require("./stellar_gas_pricing.js");
+const stellar_transaction_status_ts_1 = require("./stellar_transaction_status.js");
+const stellar_transactions_ts_1 = require("./stellar_transactions.js");
+const STELLAR_MESSAGE_PREFIX = 'Stellar Signed Message:\n';
+const NON_SAC_TOKEN_CACHE_SIZE = 2000;
+const HORIZON_DEFAULT_BASE_FEE_STROOPS = 100;
+const PythonDecimal = decimal_js_1.Decimal.clone({ precision: 28, rounding: decimal_js_1.Decimal.ROUND_HALF_EVEN });
+function stellarMessageHash(message) {
+    const messageBytes = typeof message === 'string' ? Buffer.from((0, python_builtins_ts_1.pyEncodeUtf8)(message)) : Buffer.from(message);
+    return (0, node_crypto_1.createHash)('sha256').update(Buffer.concat([Buffer.from(STELLAR_MESSAGE_PREFIX, 'utf8'), messageBytes])).digest();
+}
+class StellarSignedMessage extends wallet_base_ts_1.AbstractSignedMessage {
+    constructor(signature) {
+        super(signature);
+    }
+}
+exports.StellarSignedMessage = StellarSignedMessage;
+class StellarChain extends chain_base_ts_1.Chain {
+    chainAgnosticNamespace;
+    stellarExpertApiUrl;
+    networkPassphrase;
+    defaultHorizonUrl;
+    defaultSorobanRpcUrl;
+    horizonUrl;
+    sorobanRpcUrl;
+    _randomCallAccountId;
+    _nativeAsset;
+    _horizonServer = null;
+    _sorobanServer = null;
+    nonSacTokenCache = new Map();
+    assetDecimalsByIdentifier = new Map();
+    static _FEE_PRIORITY_MULTIPLIERS = {
+        [priority_ts_1.FeePriority.SLOW]: 1.0,
+        [priority_ts_1.FeePriority.NORMAL]: 1.0,
+        [priority_ts_1.FeePriority.FAST]: 2.0,
+    };
+    constructor(init) {
+        super(init.chainId, init.name, network_type_ts_1.NetworkType.STELLAR, 5.0, stellar_asset_ts_1.StellarAsset.NATIVE_CODE, init.explorerUrl);
+        this.chainAgnosticNamespace = `stellar:${init.chainAgnosticStellarIdentifier}`;
+        this.stellarExpertApiUrl = init.stellarExpertApiUrl;
+        this.networkPassphrase = init.networkPassphrase;
+        this._randomCallAccountId = stellar_sdk_1.Keypair.random().publicKey();
+        this._nativeAsset = new stellar_asset_ts_1.StellarAsset({
+            chainId: init.chainId,
+            networkPassphrase: init.networkPassphrase,
+            code: stellar_asset_ts_1.StellarAsset.NATIVE_CODE,
+            issuer: null,
+        });
+        this.horizonUrl = init.horizonUrl ?? null;
+        this.sorobanRpcUrl = init.sorobanRpcUrl ?? null;
+        this.defaultHorizonUrl = init.defaultHorizonUrl;
+        this.defaultSorobanRpcUrl = init.defaultSorobanRpcUrl;
+    }
+    get asyncHorizonServer() {
+        if (this._horizonServer === null) {
+            this.horizonUrl = this.horizonUrl || this._loadHorizonUrl();
+            this._horizonServer = new stellar_sdk_1.Horizon.Server(this.horizonUrl, { allowHttp: this.horizonUrl.startsWith('http://') });
+            applyAiohttpClientLimits(this._horizonServer.httpClient);
+        }
+        return this._horizonServer;
+    }
+    get asyncSorobanServer() {
+        if (this._sorobanServer === null) {
+            this.sorobanRpcUrl = this.sorobanRpcUrl || this._loadSorobanRpcUrl();
+            this._sorobanServer = new stellar_sdk_1.rpc.Server(this.sorobanRpcUrl, { allowHttp: this.sorobanRpcUrl.startsWith('http://') });
+            applyAiohttpClientLimits(this._sorobanServer.httpClient);
+        }
+        return this._sorobanServer;
+    }
+    static horizonUrlEnvForChainId(chainId) {
+        return `STELLAR_${chainId}_HORIZON_URL`;
+    }
+    static sorobanRpcUrlEnvForChainId(chainId) {
+        return `STELLAR_${chainId}_SOROBAN_RPC_URL`;
+    }
+    _loadHorizonUrl() {
+        return this.loadUrlFromEnv([`${this.envName()}_HORIZON_URL`, StellarChain.horizonUrlEnvForChainId(this.chainId)], this.defaultHorizonUrl);
+    }
+    _loadSorobanRpcUrl() {
+        return this.loadUrlFromEnv([`${this.envName()}_SOROBAN_RPC_URL`, StellarChain.sorobanRpcUrlEnvForChainId(this.chainId)], this.defaultSorobanRpcUrl);
+    }
+    get chainType() {
+        return chain_type_ts_1.ChainType.STELLAR;
+    }
+    get nativeAsset() {
+        return this._nativeAsset;
+    }
+    get nativeToken() {
+        return this._nativeAsset;
+    }
+    toString() {
+        return `StellarChain[chain_id:${this.chainId}]`;
+    }
+    getAssetExplorerUrl(asset) {
+        this.assertStellarAsset(asset);
+        if (asset.isNative())
+            return null;
+        if (asset.issuer === null)
+            return `${this.explorerBaseUrl}/contract/${asset.identifier}`;
+        return `${this.explorerBaseUrl}/asset/${asset.code}-${asset.issuer}`;
+    }
+    getWalletAddressExplorerUrl(walletAddress) {
+        return `${this.explorerBaseUrl}/account/${walletAddress}`;
+    }
+    getTransactionExplorerUrl(txHash) {
+        return `${this.explorerBaseUrl}/tx/${txHash}`;
+    }
+    getWalletExplorerUrl(address) {
+        return this.getWalletAddressExplorerUrl(address);
+    }
+    getTokenExplorerUrl(tokenIdentifier) {
+        if (!tokenIdentifier)
+            return this.explorerBaseUrl;
+        return `${this.explorerBaseUrl}/contract/${tokenIdentifier}`;
+    }
+    static formatAssetIdentifier(identifier) {
+        return identifier ?? null;
+    }
+    static validateAssetIdentifier(identifier) {
+        if (identifier === null || identifier === undefined)
+            return;
+        if (!stellar_sdk_1.StrKey.isValidContract(identifier)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidTokenIdentifier, `Invalid stellar asset identifier ${identifier}`, { identifier });
+        }
+    }
+    static formatWalletAddress(walletAddress) {
+        return walletAddress;
+    }
+    static validateWalletAddress(walletAddress) {
+        if (stellar_sdk_1.StrKey.isValidEd25519PublicKey(walletAddress))
+            return;
+        if (stellar_sdk_1.StrKey.isValidMed25519PublicKey(walletAddress))
+            return;
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidAddress, `Invalid Stellar wallet address ${walletAddress}`, { address: walletAddress });
+    }
+    static toClassicAccountId(address) {
+        return (0, stellar_transactions_ts_1.toClassicStellarAccountId)(address);
+    }
+    validateAddress(raw) {
+        try {
+            StellarChain.validateWalletAddress(raw);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validateTokenIdentifier(raw) {
+        try {
+            StellarChain.validateAssetIdentifier(raw);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getBaseFee() {
+        let latestLedger;
+        try {
+            latestLedger = (await this.asyncHorizonServer.ledgers().order('desc').limit(1).call());
+        }
+        catch (err) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, (0, errors_ts_1.sanitizeMessage)(err instanceof Error ? err.message : String(err), this.horizonUrl), { chainId: this.chainId }, (0, errors_ts_1.sanitizeCause)(err, this.horizonUrl));
+        }
+        const embedded = Array.isArray(latestLedger.records) ? { records: latestLedger.records } : (0, python_builtins_ts_1.pyItem)(latestLedger, '_embedded');
+        if (!(0, python_builtins_ts_1.pyTruthy)(embedded))
+            return HORIZON_DEFAULT_BASE_FEE_STROOPS;
+        const records = (0, python_builtins_ts_1.pyItem)(embedded, 'records');
+        if (!(0, python_builtins_ts_1.pyTruthy)(records))
+            return HORIZON_DEFAULT_BASE_FEE_STROOPS;
+        const first = Array.isArray(records) ? records[0] : (0, python_builtins_ts_1.pyItem)(records, '0');
+        if (!(0, python_builtins_ts_1.pyTruthy)(first))
+            return HORIZON_DEFAULT_BASE_FEE_STROOPS;
+        return Number((0, python_builtins_ts_1.pyIntOf)((0, python_builtins_ts_1.pyItem)(first, 'base_fee_in_stroops')));
+    }
+    async _resolveGasPricing(gasPricing) {
+        if ((0, abstract_gas_pricing_ts_1.isAbstractGasPricing)(gasPricing)) {
+            if (!(gasPricing instanceof stellar_gas_pricing_ts_1.StellarGasPricing)) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Expected StellarGasPricing for a Stellar chain, got ${gasPricing.constructor.name}`, { chainId: this.chainId });
+            }
+            return Math.max(stellar_gas_pricing_ts_1.STELLAR_MIN_BASE_FEE_STROOPS, gasPricing.baseFeeStroops);
+        }
+        if (!Object.values(priority_ts_1.FeePriority).includes(gasPricing)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Unsupported gas_pricing ${(0, python_repr_ts_1.pyRepr)(gasPricing)}`, { chainId: this.chainId });
+        }
+        const baseFee = await this.getBaseFee();
+        const scaled = Math.trunc(baseFee * StellarChain._FEE_PRIORITY_MULTIPLIERS[gasPricing]);
+        return Math.max(stellar_gas_pricing_ts_1.STELLAR_MIN_BASE_FEE_STROOPS, scaled);
+    }
+    createNonSacToken(contractId) {
+        const cached = this.nonSacTokenCache.get(contractId);
+        if (cached !== undefined) {
+            this.nonSacTokenCache.delete(contractId);
+            this.nonSacTokenCache.set(contractId, cached);
+            return cached;
+        }
+        const pending = (async () => {
+            const decimalsResp = await this._callHostFunction({ contractId, functionName: 'decimals', parameters: [] });
+            const decimals = scvalToUint32(firstHostFunctionResult(decimalsResp));
+            const symbolResp = await this._callHostFunction({ contractId, functionName: 'symbol', parameters: [] });
+            const symbol = scvalToUtf8String(firstHostFunctionResult(symbolResp));
+            return new stellar_asset_ts_1.StellarAsset({
+                chainId: this.chainId,
+                networkPassphrase: this.networkPassphrase,
+                code: symbol,
+                issuer: null,
+                contractId,
+                decimals,
+            });
+        })();
+        this.nonSacTokenCache.set(contractId, pending);
+        if (this.nonSacTokenCache.size > NON_SAC_TOKEN_CACHE_SIZE) {
+            const oldest = this.nonSacTokenCache.keys().next().value;
+            this.nonSacTokenCache.delete(oldest);
+        }
+        pending.catch(() => {
+            if (this.nonSacTokenCache.get(contractId) === pending)
+                this.nonSacTokenCache.delete(contractId);
+        });
+        return pending;
+    }
+    createSacToken(code, issuer) {
+        return new stellar_asset_ts_1.StellarAsset({
+            chainId: this.chainId,
+            networkPassphrase: this.networkPassphrase,
+            code,
+            issuer,
+        });
+    }
+    async resolveAsset(identifier) {
+        if (identifier === null ||
+            identifier === undefined ||
+            identifier === stellar_asset_ts_1.StellarAsset.PUBLIC_NATIVE_CONTRACT_ID ||
+            identifier === stellar_asset_ts_1.StellarAsset.TESTNET_NATIVE_CONTRACT_ID) {
+            return this._nativeAsset;
+        }
+        const decimalsResults = await this._callHostFunction({ contractId: identifier, functionName: 'decimals', parameters: [] });
+        const decimals = scvalToUint32(firstHostFunctionResult(decimalsResults));
+        const nameResults = await this._callHostFunction({ contractId: identifier, functionName: 'name', parameters: [] });
+        const name = scvalToUtf8String(firstHostFunctionResult(nameResults));
+        let code;
+        let issuer;
+        if (name === 'native') {
+            return this._nativeAsset;
+        }
+        else if (!name.includes(':')) {
+            const symbolResults = await this._callHostFunction({ contractId: identifier, functionName: 'symbol', parameters: [] });
+            code = scvalToUtf8String(firstHostFunctionResult(symbolResults));
+            issuer = null;
+        }
+        else {
+            const separator = name.indexOf(':');
+            code = name.slice(0, separator);
+            issuer = name.slice(separator + 1);
+        }
+        return new stellar_asset_ts_1.StellarAsset({
+            chainId: this.chainId,
+            networkPassphrase: this.networkPassphrase,
+            code,
+            issuer,
+            contractId: identifier,
+            decimals,
+        });
+    }
+    createAsset(_symbol, _identifier, _decimals) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.FeatureNotSupported, 'Cannot create asset for stellar via create_asset method', {
+            chainId: this.chainId,
+        });
+    }
+    async _callHostFunction(req) {
+        if (!stellar_sdk_1.StrKey.isValidContract(req.contractId)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidTokenIdentifier, '`contract_id` is invalid.', {
+                chainId: this.chainId,
+                identifier: req.contractId,
+            });
+        }
+        const account = req.accountId === undefined || req.accountId === null
+            ? new stellar_sdk_1.Account(this._randomCallAccountId, '0')
+            : await this.soroban(this.asyncSorobanServer.getAccount(req.accountId));
+        const tx = new stellar_sdk_1.TransactionBuilder(account, { fee: '300', networkPassphrase: this.networkPassphrase })
+            .addOperation(stellar_sdk_1.Operation.invokeContractFunction({
+            contract: req.contractId,
+            function: req.functionName,
+            args: req.parameters,
+        }))
+            .setTimeout(300)
+            .build();
+        return (await (0, stellar_transactions_ts_1.simulateSorobanTransaction)(tx, this)).results;
+    }
+    async _sorobanRpc(method, params) {
+        const soroban = this.asyncSorobanServer;
+        const body = { jsonrpc: '2.0', id: (0, node_crypto_1.randomUUID)().replace(/-/g, ''), method, params };
+        const config = { validateStatus: () => true, responseType: 'text', transformResponse: [(data) => data] };
+        const response = await soroban.httpClient.post(soroban.serverURL.toString(), body, config);
+        let reply;
+        try {
+            reply = JSON.parse(String(response.data));
+        }
+        catch {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, `Soroban ${method} returned a body that is not valid JSON (HTTP ${response.status})`, {
+                chainId: this.chainId,
+            });
+        }
+        const error = (0, python_pydantic_ts_1.isPydanticDict)(reply) ? reply.error : undefined;
+        const validEnvelope = (0, python_pydantic_ts_1.isPydanticDict)(reply) &&
+            typeof reply.jsonrpc === 'string' &&
+            (typeof reply.id === 'string' || (0, python_pydantic_ts_1.isPydanticLaxInt)(reply.id)) &&
+            ((0, python_pydantic_ts_1.isPydanticAbsent)(error) ||
+                ((0, python_pydantic_ts_1.isPydanticDict)(error) && (0, python_pydantic_ts_1.isPydanticLaxInt)(error.code) && (0, python_pydantic_ts_1.isPydanticOptionalStr)(error.message) && (0, python_pydantic_ts_1.isPydanticOptionalStr)(error.data)));
+        if (!validEnvelope) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, `Soroban ${method} reply does not match the JSON-RPC Response model`, { chainId: this.chainId });
+        }
+        const envelope = reply;
+        if ((0, python_pydantic_ts_1.isPydanticDict)(error)) {
+            throw new stellar_transactions_ts_1.SorobanRpcErrorResponse(Number((0, python_pydantic_ts_1.pydanticLaxIntValue)(error.code)), error.message, error.data, this.chainId);
+        }
+        if ((0, python_pydantic_ts_1.isPydanticAbsent)(envelope.result)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, '', { chainId: this.chainId });
+        }
+        return envelope.result;
+    }
+    async _getAssetDecimalsInternal(_symbol, identifier) {
+        try {
+            const decimalsResult = await this._callHostFunction({
+                contractId: identifier,
+                functionName: 'decimals',
+                parameters: [],
+            });
+            return scvalToUint32(firstHostFunctionResult(decimalsResult));
+        }
+        catch {
+            return stellar_asset_ts_1.StellarAsset.DECIMALS;
+        }
+    }
+    async getCachedAssetDecimals(symbol, identifier) {
+        if (identifier === null || identifier === undefined) {
+            if (symbol !== this._nativeAsset.symbol) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid native asset symbol ${symbol}`, { chainId: this.chainId });
+            }
+            return this._nativeAsset.decimals;
+        }
+        let decimals = this.assetDecimalsByIdentifier.get(identifier);
+        if (decimals === undefined) {
+            decimals = await this._getAssetDecimalsInternal(symbol, identifier);
+            this.assetDecimalsByIdentifier.set(identifier, decimals);
+        }
+        return decimals;
+    }
+    async _checkMemoRequired(transaction) {
+        if (transaction.memo.type !== stellar_sdk_1.MemoNone)
+            return;
+        const checked = new Set();
+        for (const [index, operation] of transaction.operations.entries()) {
+            if (!MEMO_REQUIRED_OPERATION_TYPES.has(operation.type))
+                continue;
+            const destination = StellarChain._muxedToClassic(operation.destination);
+            if (checked.has(destination))
+                continue;
+            checked.add(destination);
+            if (destination.startsWith('M'))
+                continue;
+            let account;
+            try {
+                account = (await this.asyncHorizonServer.accounts().accountId(destination).call());
+            }
+            catch (err) {
+                if (err instanceof stellar_sdk_1.NotFoundError)
+                    continue;
+                throw err;
+            }
+            const dataRenamedBySdk = (0, python_pydantic_ts_1.isPydanticDict)(account._links) && 'data' in account._links;
+            if (dataRenamedBySdk && !('data_attr' in account))
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, (0, python_repr_ts_1.pyRepr)('data'));
+            const data = dataRenamedBySdk ? account.data_attr : (0, python_builtins_ts_1.pyItem)(account, 'data');
+            if (!(0, python_pydantic_ts_1.isPydanticDict)(data)) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, `'${(0, python_repr_ts_1.pyTypeName)(data)}' object has no attribute 'get'`, { chainId: this.chainId });
+            }
+            if (data[MEMO_REQUIRED_CONFIG_KEY] === MEMO_REQUIRED_CONFIG_VALUE) {
+                throw new stellar_sdk_1.AccountRequiresMemoError('Destination account requires a memo in the transaction.', destination, index);
+            }
+        }
+    }
+    async _submitTransaction(envelope) {
+        const horizon = this.asyncHorizonServer;
+        await this._checkMemoRequired(envelope);
+        const response = await horizon.httpClient.post(horizon.serverURL.clone().segment('transactions').toString(), `tx=${encodeURIComponent(envelope.toEnvelope().toXDR().toString('base64'))}`, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+        return response.data;
+    }
+    async _loadAccountData(accountId) {
+        return this.asyncHorizonServer.accounts().accountId(accountId).call();
+    }
+    async getAssetBalance(asset, ownerAddress) {
+        this.assertStellarAsset(asset);
+        StellarChain.validateWalletAddress(ownerAddress);
+        const ownerClassicAddress = StellarChain.toClassicAccountId(ownerAddress);
+        if (asset.isNative() || asset.isSac()) {
+            const accountData = await this._loadAccountData(ownerClassicAddress);
+            const balances = (accountData.balances ?? []);
+            if (asset.isNative()) {
+                const record = accountData;
+                const subentryCount = Math.trunc(Number(record.subentry_count ?? 0));
+                const numSponsoring = Math.trunc(Number(record.num_sponsoring ?? 0));
+                const numSponsored = Math.trunc(Number(record.num_sponsored ?? 0));
+                const reserveUnits = 2 + subentryCount + numSponsoring - numSponsored;
+                const reservedStroops = BigInt(reserveUnits) * 5000000n;
+                for (const b of balances) {
+                    if (b.asset_type === 'native') {
+                        const totalStroops = (0, transaction_status_ts_1.hrDecimalToMinorUnits)(new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(b, 'balance'))), stellar_asset_ts_1.StellarAsset.DECIMALS);
+                        const availableStroops = totalStroops - reservedStroops;
+                        return new decimal_js_1.Decimal((0, transaction_status_ts_1.minorUnitsToHrString)(availableStroops < 0n ? 0n : availableStroops, stellar_asset_ts_1.StellarAsset.DECIMALS));
+                    }
+                }
+                return new decimal_js_1.Decimal(0);
+            }
+            for (const b of balances) {
+                if (b.asset_type === 'native')
+                    continue;
+                if (b.asset_code === asset.code && b.asset_issuer === asset.issuer) {
+                    return new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(b, 'balance')));
+                }
+            }
+            return new decimal_js_1.Decimal(0);
+        }
+        const result = await this._callHostFunction({
+            contractId: asset.contractId,
+            functionName: 'balance',
+            parameters: [new stellar_sdk_1.Address(ownerClassicAddress).toScVal()],
+        });
+        const balance = scvalToInt128(firstHostFunctionResult(result));
+        return new decimal_js_1.Decimal((0, transaction_status_ts_1.minorUnitsToHrString)(balance, asset.decimals));
+    }
+    async getWalletBalance(ownerAddress) {
+        const ownerClassicAddress = StellarChain.toClassicAccountId(ownerAddress);
+        const accountData = await this._loadAccountData(ownerClassicAddress);
+        const balances = (accountData.balances ?? []);
+        const result = new asset_map_ts_1.AssetMap();
+        for (const b of balances) {
+            if (b.asset_type === 'native') {
+                result.set(this._nativeAsset, new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(b, 'balance'))));
+            }
+            else {
+                const code = b.asset_code;
+                const issuer = b.asset_issuer;
+                if (code === undefined || code === null || issuer === undefined || issuer === null)
+                    continue;
+                result.set(this.createSacToken(code, issuer), new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(b, 'balance'))));
+            }
+        }
+        return result;
+    }
+    async getTrustLineLimit(walletAddress, asset) {
+        this.assertStellarAsset(asset);
+        if (asset.isNative()) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Cannot get trustline for native XLM asset ${String(asset)}`, { chainId: this.chainId });
+        }
+        const classicAddress = StellarChain.toClassicAccountId(walletAddress);
+        const accountData = await this._loadAccountData(classicAddress);
+        const trustLine = { balance: new decimal_js_1.Decimal(0), limit: new decimal_js_1.Decimal(0) };
+        for (const b of (accountData.balances ?? [])) {
+            if (b.asset_type === 'native')
+                continue;
+            if (b.asset_code === asset.code && b.asset_issuer === asset.issuer) {
+                trustLine.limit = new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)('limit' in b ? b.limit : '0'));
+                trustLine.balance = new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)('balance' in b ? b.balance : '0'));
+            }
+        }
+        return trustLine;
+    }
+    createPrerequisiteForReceivableAsset(receiveAsset, receiverAddress) {
+        this.assertStellarAsset(receiveAsset);
+        if (receiveAsset.chainId !== this.chainId) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid chain id ${receiveAsset.chainId} for ${String(receiveAsset)}, expected ${this.chainId}.`, { chainId: this.chainId });
+        }
+        StellarChain.validateWalletAddress(receiverAddress);
+        const receiverClassicAddress = StellarChain.toClassicAccountId(receiverAddress);
+        if (receiveAsset.isNative())
+            return null;
+        if (!receiveAsset.isSac())
+            return null;
+        return new stellar_transactions_ts_1.StellarChangeTrustLineTransactionPrerequisite({
+            chainId: this.chainId,
+            code: receiveAsset.code,
+            issuer: receiveAsset.issuer,
+            limit: new decimal_js_1.Decimal(stellar_asset_ts_1.StellarAsset.TRUST_LINE_MAX_LIMIT),
+            walletAddress: receiverClassicAddress,
+        });
+    }
+    buildUnsignedTransaction(req) {
+        return new stellar_transactions_ts_1.StellarUnsignedTransaction({
+            chainId: this.chainId,
+            sourceAccountId: req.sourceAddress,
+            operations: req.operations,
+            baseFee: req.baseFee ?? null,
+            memo: req.memoText ? (0, stellar_transactions_ts_1.stellarTextMemo)(req.memoText) : null,
+        });
+    }
+    buildTokenTransferOperation(req) {
+        return stellar_sdk_1.Operation.invokeContractFunction({
+            contract: req.asset.contractId,
+            function: 'transfer',
+            args: [
+                new stellar_sdk_1.Address(req.senderAddress).toScVal(),
+                new stellar_sdk_1.Address(req.receiverAddress).toScVal(),
+                (0, stellar_sdk_1.nativeToScVal)((0, transaction_status_ts_1.hrDecimalToMinorUnits)(new decimal_js_1.Decimal(req.amountHr.toString()), req.asset.decimals), { type: 'i128' }),
+            ],
+        });
+    }
+    async createTransferTransaction(req) {
+        const asset = req.asset;
+        this.assertStellarAsset(asset);
+        if (asset.chainId !== this.chainId) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid chain id ${asset.chainId} for asset ${String(asset)}, expected ${this.chainId}.`, { chainId: this.chainId });
+        }
+        StellarChain.validateWalletAddress(req.senderAddress);
+        const receiverIsContract = stellar_sdk_1.StrKey.isValidContract(req.receiverAddress);
+        if (!receiverIsContract) {
+            StellarChain.validateWalletAddress(req.receiverAddress);
+        }
+        const senderClassicAddress = StellarChain.toClassicAccountId(req.senderAddress);
+        const receiverTargetAddress = receiverIsContract ? req.receiverAddress : StellarChain.toClassicAccountId(req.receiverAddress);
+        const useClassicPayment = (asset.isNative() || asset.isSac()) && !receiverIsContract;
+        const memoText = req.memoText ?? null;
+        if (!useClassicPayment && memoText) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Cannot transfer ${asset.symbol} to ${req.receiverAddress} with a memo: it requires a Soroban \`transfer\` invocation, and Soroban transactions do not support memos.`, { chainId: this.chainId });
+        }
+        const transferOp = useClassicPayment
+            ? stellar_sdk_1.Operation.payment({
+                source: senderClassicAddress,
+                destination: receiverTargetAddress,
+                asset: asset.toSdkAsset(),
+                amount: (0, stellar_transactions_ts_1.stellarOperationAmount)(req.amountHr, 'amount'),
+            })
+            : this.buildTokenTransferOperation({
+                asset,
+                senderAddress: senderClassicAddress,
+                receiverAddress: receiverTargetAddress,
+                amountHr: req.amountHr,
+            });
+        const baseFee = await this._resolveGasPricing(req.gasPricing === undefined ? priority_ts_1.FeePriority.NORMAL : req.gasPricing);
+        const unsignedTx = new stellar_transactions_ts_1.StellarUnsignedTransaction({
+            chainId: this.chainId,
+            sourceAccountId: senderClassicAddress,
+            operations: [transferOp],
+            baseFee,
+            memo: memoText ? (0, stellar_transactions_ts_1.stellarTextMemo)(memoText) : null,
+        });
+        const prerequisites = [];
+        if (!receiverIsContract) {
+            const prerequisite = this.createPrerequisiteForReceivableAsset(asset, receiverTargetAddress);
+            if (prerequisite !== null)
+                prerequisites.push(prerequisite);
+        }
+        return new transaction_prerequisite_ts_1.UnsignedTransactionWithPrerequisites({ prerequisites, transaction: unsignedTx });
+    }
+    async createExactInSwapTransaction(req) {
+        const senderClassicAddress = StellarChain.toClassicAccountId(req.senderAddress);
+        const receiverClassicAddress = StellarChain.toClassicAccountId(req.receiverAddress);
+        const sendPath = await this.asyncHorizonServer
+            .strictSendPaths(req.sendAsset.toSdkAsset(), (0, python_builtins_ts_1.pyDecimalStr)(req.sendAmount.toString()), [req.receiveAsset.toSdkAsset()])
+            .call();
+        const records = sendPath.records;
+        if (records.length === 0) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'Cannot find a swap route', { chainId: this.chainId });
+        }
+        const bestRecord = records[0];
+        const path = bestRecord.path.map((p) => p.asset_type === 'native' ? this._nativeAsset.toSdkAsset() : (0, stellar_asset_ts_1.stellarSdkAsset)(p.asset_code, p.asset_issuer));
+        const destinationAmount = new PythonDecimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(bestRecord, 'destination_amount')));
+        const minimumReceiveValue = destinationAmount
+            .mul(new PythonDecimal(1).minus(new PythonDecimal(req.slippageTolerancePercent.toString()).div(new PythonDecimal(100))))
+            .toDecimalPlaces(req.receiveAsset.decimals, decimal_js_1.Decimal.ROUND_HALF_UP);
+        const prerequisite = this.createPrerequisiteForReceivableAsset(req.receiveAsset, receiverClassicAddress);
+        const prerequisites = [];
+        if (prerequisite !== null)
+            prerequisites.push(prerequisite);
+        const unsignedTx = new stellar_transactions_ts_1.StellarUnsignedTransaction({
+            chainId: this.chainId,
+            sourceAccountId: senderClassicAddress,
+            operations: [
+                stellar_sdk_1.Operation.pathPaymentStrictSend({
+                    sendAsset: req.sendAsset.toSdkAsset(),
+                    sendAmount: (0, stellar_transactions_ts_1.stellarOperationAmount)(req.sendAmount, 'send_amount'),
+                    destAsset: req.receiveAsset.toSdkAsset(),
+                    destMin: (0, stellar_transactions_ts_1.stellarOperationAmount)(minimumReceiveValue, 'dest_min'),
+                    path,
+                    source: senderClassicAddress,
+                    destination: receiverClassicAddress,
+                }),
+            ],
+        });
+        return new transaction_prerequisite_ts_1.UnsignedTransactionWithPrerequisites({ prerequisites, transaction: unsignedTx });
+    }
+    static _muxedToClassic(account) {
+        if (account instanceof stellar_sdk_1.MuxedAccount)
+            return account.baseAccount().accountId();
+        return (0, stellar_transactions_ts_1.toClassicStellarAccountId)(account);
+    }
+    _balanceChangesFromOperations(tx, opts = {}) {
+        const { filteredWallets = null, filteredAssets = null } = opts;
+        const includeNative = filteredAssets === null || filteredAssets.some((a) => a.isNative());
+        const filteredAssetsByIdentifier = filteredAssets === null ? null : this.identifierIndex(filteredAssets);
+        const txSourceClassic = StellarChain._muxedToClassic(tx.source);
+        const balanceChanges = new Map();
+        const record = (account, sdkAsset, deltaHr) => {
+            if (filteredWallets !== null && !(0, python_builtins_ts_1.pyContains)(filteredWallets, account))
+                return;
+            let stellarAsset;
+            if (sdkAsset.isNative()) {
+                if (!includeNative)
+                    return;
+                stellarAsset = this._nativeAsset;
+            }
+            else {
+                stellarAsset = this.createSacToken(sdkAsset.getCode(), sdkAsset.getIssuer());
+                if (filteredAssetsByIdentifier !== null && !filteredAssetsByIdentifier.has(stellarAsset.identifier))
+                    return;
+            }
+            transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, account, stellarAsset, transaction_status_ts_1.AssetBalanceChange.fromHr(deltaHr, stellarAsset.decimals));
+        };
+        const rawOperations = transactionXdrOperations(tx);
+        for (const [index, op] of tx.operations.entries()) {
+            const opSource = op.source ? StellarChain._muxedToClassic(op.source) : txSourceClassic;
+            const body = rawOperations[index].body();
+            if (op.type === 'payment') {
+                const asset = (0, stellar_asset_ts_1.stellarSdkAssetFromXdr)(body.paymentOp().asset());
+                const amountHr = new decimal_js_1.Decimal(op.amount);
+                const destination = StellarChain._muxedToClassic(op.destination);
+                record(opSource, asset, amountHr.neg());
+                record(destination, asset, amountHr);
+            }
+            else if (op.type === 'pathPaymentStrictSend') {
+                const raw = body.pathPaymentStrictSendOp();
+                const sendAmountHr = new decimal_js_1.Decimal(op.sendAmount);
+                const destMin = new decimal_js_1.Decimal(op.destMin);
+                const destination = StellarChain._muxedToClassic(op.destination);
+                record(opSource, (0, stellar_asset_ts_1.stellarSdkAssetFromXdr)(raw.sendAsset()), sendAmountHr.neg());
+                record(destination, (0, stellar_asset_ts_1.stellarSdkAssetFromXdr)(raw.destAsset()), destMin);
+            }
+            else if (op.type === 'pathPaymentStrictReceive') {
+                const raw = body.pathPaymentStrictReceiveOp();
+                const sendMax = new decimal_js_1.Decimal(op.sendMax);
+                const destAmount = new decimal_js_1.Decimal(op.destAmount);
+                const destination = StellarChain._muxedToClassic(op.destination);
+                record(opSource, (0, stellar_asset_ts_1.stellarSdkAssetFromXdr)(raw.sendAsset()), sendMax.neg());
+                record(destination, (0, stellar_asset_ts_1.stellarSdkAssetFromXdr)(raw.destAsset()), destAmount);
+            }
+        }
+        return balanceChanges;
+    }
+    async _getTransactionDataFromStellarExpert(pagingToken) {
+        const url = `${this.stellarExpertApiUrl}/tx/${pagingToken}`;
+        const response = await fetch(url, { signal: AbortSignal.timeout(AIOHTTP_DEFAULT_TOTAL_TIMEOUT_MS) });
+        return (0, stellar_transactions_ts_1.parseStellarExpertTransactionInfo)(await response.json());
+    }
+    async getTransactionStatus(txHash, opts) {
+        if (opts?.wait || (opts?.confirmations !== undefined && opts.confirmations > 1)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.FeatureNotSupported, 'StellarChain.getTransactionStatus does not honor wait/confirmations opts (would silently return immediately). Poll consumer-side or omit the opts.', { chainId: this.chainId });
+        }
+        const filteredWallets = opts?.filteredWallets === undefined || opts.filteredWallets === null ? null : (0, python_builtins_ts_1.pyStringContainer)(opts.filteredWallets);
+        const filteredAssets = opts?.filteredAssets === undefined || opts.filteredAssets === null ? null : [...opts.filteredAssets];
+        if (Array.isArray(txHash)) {
+            return runBatch(txHash, (hash) => this.getTransactionStatusOnce(hash, filteredWallets, filteredAssets));
+        }
+        return this.getTransactionStatusOnce(txHash, filteredWallets, filteredAssets);
+    }
+    async getTransactionStatusOnce(txHash, filteredWallets, filteredAssets) {
+        let txResp;
+        try {
+            txResp = await this.asyncHorizonServer.transactions().transaction(txHash).call();
+        }
+        catch (err) {
+            if (err instanceof stellar_sdk_1.NotFoundError) {
+                return stellar_transaction_status_ts_1.StellarTransactionStatus.notFound(this.chainId, { code: 'NOT_FOUND', reason: err.message });
+            }
+            throw this.rpcError(`Horizon transaction lookup failed for ${txHash}`, err, txHash, this.horizonUrl);
+        }
+        const ledger = await this.asyncHorizonServer.ledgers().ledger(txResp.ledger_attr).call();
+        const inclusionAt = new Date(ledger.closed_at);
+        const raw = txResp;
+        const pagingToken = String(raw.paging_token);
+        const successful = Boolean(raw.successful);
+        const envelopeXdr = String(raw.envelope_xdr);
+        let fees = null;
+        if ('fee_charged' in raw) {
+            const feePayer = String(raw.fee_account);
+            const feeCharged = Math.trunc(Number(raw.fee_charged ?? raw.max_fee ?? '0'));
+            fees = new stellar_transactions_ts_1.StellarTransactionFees({ feeStroops: feeCharged, feePayer });
+        }
+        const txEnvelope = stellar_sdk_1.xdr.TransactionEnvelope.fromXDR(envelopeXdr, 'base64');
+        let operationsXdr;
+        let memoXdr;
+        switch (txEnvelope.switch().name) {
+            case 'envelopeTypeTxFeeBump': {
+                const inner = txEnvelope.feeBump().tx().innerTx().v1().tx();
+                operationsXdr = inner.operations();
+                memoXdr = inner.memo();
+                break;
+            }
+            case 'envelopeTypeTxV0': {
+                const inner = txEnvelope.v0().tx();
+                operationsXdr = inner.operations();
+                memoXdr = inner.memo();
+                break;
+            }
+            case 'envelopeTypeTx': {
+                const inner = txEnvelope.v1().tx();
+                operationsXdr = inner.operations();
+                memoXdr = inner.memo();
+                break;
+            }
+            default:
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Unknown envelope type: ${txEnvelope.switch().name}`, {
+                    chainId: this.chainId,
+                    txHash,
+                });
+        }
+        const memo = stellar_sdk_1.Memo.fromXDRObject(memoXdr);
+        if (!successful) {
+            const extras = raw.extras;
+            const resultCodes = extras?.result_codes || raw.result_codes;
+            const errorMessage = resultCodes ? `Stellar transaction failed: ${(0, python_repr_ts_1.pyRepr)(resultCodes)}` : 'Stellar transaction failed';
+            return stellar_transaction_status_ts_1.StellarTransactionStatus.failed({
+                chainId: this.chainId,
+                inclusionAt,
+                error: { code: 'FAILED', reason: errorMessage },
+                fees,
+                memo,
+            });
+        }
+        const operations = operationsXdr.map((op) => stellar_sdk_1.Operation.fromXDRObject(op));
+        const isContractCall = operations.length === 1 && operations[0].type === 'invokeHostFunction';
+        if (isContractCall) {
+            if (operations.length > 1) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Soroban contract call cannot have more than 1 operation ${txHash}`, { chainId: this.chainId, txHash });
+            }
+            let sorobanTxResp;
+            try {
+                const reply = await this._sorobanRpc('getTransaction', { hash: txHash });
+                sorobanTxResp = isGetTransactionResponse(reply) ? reply : null;
+            }
+            catch {
+                sorobanTxResp = null;
+            }
+            const sorobanDiagnosticEvents = sorobanTxResp?.events?.diagnosticEventsXdr;
+            const hasSorobanTxResp = sorobanTxResp !== null &&
+                sorobanTxResp.status !== stellar_sdk_1.rpc.Api.GetTransactionStatus.NOT_FOUND &&
+                sorobanDiagnosticEvents !== undefined &&
+                sorobanDiagnosticEvents !== null;
+            let stellarExpertResult = null;
+            if (!hasSorobanTxResp) {
+                try {
+                    stellarExpertResult = await this._getTransactionDataFromStellarExpert(pagingToken);
+                }
+                catch {
+                    stellarExpertResult = null;
+                }
+            }
+            if (hasSorobanTxResp && sorobanTxResp !== null) {
+                const balanceChanges = await this.getBalanceChangesFromDiagnosisEvents(sorobanDiagnosticEvents.map((d) => stellar_sdk_1.xdr.DiagnosticEvent.fromXDR(d, 'base64')), { filteredWallets, filteredAssets });
+                this.upsertFee(balanceChanges, fees);
+                if (sorobanTxResp.status === stellar_sdk_1.rpc.Api.GetTransactionStatus.SUCCESS) {
+                    return stellar_transaction_status_ts_1.StellarTransactionStatus.successful({ chainId: this.chainId, inclusionAt, balanceChanges, fees, memo });
+                }
+                return stellar_transaction_status_ts_1.StellarTransactionStatus.failed({
+                    chainId: this.chainId,
+                    inclusionAt,
+                    error: {
+                        code: String(sorobanTxResp.status),
+                        reason: `Stellar soroban transaction failed: GetTransactionStatus.${sorobanTxResp.status}`,
+                    },
+                    fees,
+                    memo,
+                });
+            }
+            else if (stellarExpertResult !== null) {
+                const txEnv = (0, stellar_transactions_ts_1.parseSignedStellarEnvelope)(stellarExpertResult.body, this.networkPassphrase);
+                const txMeta = stellar_sdk_1.xdr.TransactionMeta.fromXDR(stellarExpertResult.meta, 'base64');
+                const ops = txEnv.operations;
+                if (!(ops.length === 1 && ops[0].type === 'invokeHostFunction')) {
+                    throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Stellar expert returned envelope is not contract call, operations: ${ops.map((o) => o.type).join(',')}`, { chainId: this.chainId, txHash });
+                }
+                if (txMeta.switch() !== 4) {
+                    throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Unsupported transaction metadata version ${txMeta.switch()}`, {
+                        chainId: this.chainId,
+                        txHash,
+                    });
+                }
+                const txResult = stellar_sdk_1.xdr.TransactionResult.fromXDR(stellarExpertResult.result, 'base64');
+                const balanceChanges = await this.getBalanceChangesFromDiagnosisEvents(txMeta.v4().diagnosticEvents(), { filteredWallets, filteredAssets });
+                this.upsertFee(balanceChanges, fees);
+                const resultCode = txResult.result().switch();
+                if (resultCode.name === 'txSuccess') {
+                    return stellar_transaction_status_ts_1.StellarTransactionStatus.successful({ chainId: this.chainId, inclusionAt, balanceChanges, fees, memo });
+                }
+                return stellar_transaction_status_ts_1.StellarTransactionStatus.failed({
+                    chainId: this.chainId,
+                    inclusionAt,
+                    error: { code: resultCode.name, reason: `Stellar transaction failed: ${resultCode.value}` },
+                    fees,
+                    memo,
+                });
+            }
+            else {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, `Cannot get status of transaction from soroban rpc and stellar expert for tx hash ${txHash}`, { chainId: this.chainId, txHash });
+            }
+        }
+        const balanceChanges = await this._effectsToBalanceChanges(txHash, { filteredWallets, filteredAssets });
+        this.upsertFee(balanceChanges, fees);
+        return stellar_transaction_status_ts_1.StellarTransactionStatus.successful({ chainId: this.chainId, inclusionAt, balanceChanges, fees, memo });
+    }
+    async _effectsToBalanceChanges(txHash, opts = {}) {
+        const { filteredWallets = null, filteredAssets = null } = opts;
+        const includeNative = filteredAssets === null || filteredAssets.some((a) => a.isNative());
+        const filteredAssetsByIdentifier = filteredAssets === null ? null : this.identifierIndex(filteredAssets);
+        const balanceChanges = new Map();
+        const page = await this.asyncHorizonServer.effects().forTransaction(txHash).limit(200).call();
+        const records = (page.records ?? []);
+        const buildAsset = (rec) => {
+            if (rec.asset_type === 'native') {
+                return includeNative ? this._nativeAsset : null;
+            }
+            const code = rec.asset_code;
+            const issuer = rec.asset_issuer;
+            if (code === undefined || code === null || issuer === undefined || issuer === null)
+                return null;
+            const stellarAsset = this.createSacToken(code, issuer);
+            if (filteredAssetsByIdentifier !== null && !filteredAssetsByIdentifier.has(stellarAsset.identifier))
+                return null;
+            return stellarAsset;
+        };
+        const operationId = (rec) => String(rec.id ?? '').split('-')[0];
+        const nativelyCreditedByOperation = new Set();
+        for (const rec of records) {
+            if (rec.type === 'account_credited' && rec.asset_type === 'native') {
+                if (rec.account)
+                    nativelyCreditedByOperation.add(`${operationId(rec)}|${rec.account}`);
+            }
+        }
+        for (const rec of records) {
+            const eType = rec.type;
+            const wallet = eType === 'contract_credited' || eType === 'contract_debited' ? rec.contract : rec.account;
+            if (!wallet)
+                continue;
+            if (filteredWallets !== null && !(0, python_builtins_ts_1.pyContains)(filteredWallets, wallet))
+                continue;
+            if (eType === 'account_credited' || eType === 'contract_credited') {
+                const stellarAsset = buildAsset(rec);
+                if (stellarAsset === null)
+                    continue;
+                transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, wallet, stellarAsset, transaction_status_ts_1.AssetBalanceChange.fromHr(new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(rec, 'amount'))), stellarAsset.decimals));
+            }
+            else if (eType === 'account_debited' || eType === 'contract_debited') {
+                const stellarAsset = buildAsset(rec);
+                if (stellarAsset === null)
+                    continue;
+                transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, wallet, stellarAsset, transaction_status_ts_1.AssetBalanceChange.fromHr(new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(rec, 'amount'))).neg(), stellarAsset.decimals));
+            }
+            else if (eType === 'account_created') {
+                if (!includeNative)
+                    continue;
+                const stellarAsset = this._nativeAsset;
+                const startingBalance = new decimal_js_1.Decimal((0, python_builtins_ts_1.pyDecimalString)((0, python_builtins_ts_1.pyItem)(rec, 'starting_balance')));
+                if (nativelyCreditedByOperation.has(`${operationId(rec)}|${wallet}`))
+                    continue;
+                transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, wallet, stellarAsset, transaction_status_ts_1.AssetBalanceChange.fromHr(startingBalance, stellarAsset.decimals));
+            }
+        }
+        return balanceChanges;
+    }
+    static getTransfersFromDiagnosisEvents(diagnosisEvents) {
+        const transfers = [];
+        for (const d of diagnosisEvents) {
+            const event = d.event();
+            const contractId = event.contractId();
+            const topics = event.body().v0().topics();
+            if (contractId && topics.length > 0) {
+                const tokenContractId = stellar_sdk_1.StrKey.encodeContract(contractId);
+                if (topics[0].switch().name === 'scvSymbol') {
+                    const topic0 = topics[0].sym().toString();
+                    if (topic0 === 'transfer') {
+                        if (topics.length < 3)
+                            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, 'list index out of range');
+                        const transferFrom = stellar_sdk_1.Address.fromScVal(topics[1]).toString();
+                        const transferTo = stellar_sdk_1.Address.fromScVal(topics[2]).toString();
+                        let contractSacCode;
+                        let contractSacIssuer;
+                        if (topics.length > 3) {
+                            const tokenIdentifier = scvalToUtf8String(topics[3]);
+                            if (tokenIdentifier === 'native') {
+                                contractSacCode = 'XLM';
+                                contractSacIssuer = null;
+                            }
+                            else if (tokenIdentifier.includes(':')) {
+                                const splitted = tokenIdentifier.split(':');
+                                contractSacCode = splitted[0];
+                                contractSacIssuer = splitted[1];
+                            }
+                            else {
+                                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Invalid token identifier ${tokenIdentifier}`);
+                            }
+                        }
+                        else {
+                            contractSacCode = null;
+                            contractSacIssuer = null;
+                        }
+                        const transferAmountMr = scvalToInt128(event.body().v0().data());
+                        transfers.push({
+                            fromAccount: transferFrom,
+                            toAccount: transferTo,
+                            tokenContractId,
+                            tokenContractSacCode: contractSacCode,
+                            tokenContractSacIssuer: contractSacIssuer,
+                            amountMr: transferAmountMr,
+                        });
+                    }
+                }
+            }
+        }
+        return transfers;
+    }
+    async getBalanceChangesFromDiagnosisEvents(diagnosisEvents, opts = {}) {
+        const { filteredWallets = null, filteredAssets = null } = opts;
+        const tokenTransfers = StellarChain.getTransfersFromDiagnosisEvents(diagnosisEvents);
+        const balanceChanges = new Map();
+        for (const t of tokenTransfers) {
+            const asset = t.tokenContractSacCode !== null
+                ? this.createSacToken(t.tokenContractSacCode, t.tokenContractSacIssuer)
+                : await this.createNonSacToken(t.tokenContractId);
+            if (filteredAssets !== null && !filteredAssets.some((a) => a.strictEquals(asset)))
+                continue;
+            if (filteredWallets === null || (0, python_builtins_ts_1.pyContains)(filteredWallets, t.fromAccount)) {
+                transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, t.fromAccount, asset, transaction_status_ts_1.AssetBalanceChange.fromMr(-t.amountMr, asset.decimals));
+            }
+            if (filteredWallets === null || (0, python_builtins_ts_1.pyContains)(filteredWallets, t.toAccount)) {
+                transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, t.toAccount, asset, transaction_status_ts_1.AssetBalanceChange.fromMr(t.amountMr, asset.decimals));
+            }
+        }
+        return balanceChanges;
+    }
+    async supportsFullTransactionSimulation(unsignedTransaction) {
+        if (!(unsignedTransaction instanceof stellar_transactions_ts_1.StellarUnsignedTransaction)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'Expected StellarUnsignedTransaction', { chainId: this.chainId });
+        }
+        return true;
+    }
+    async simulateTransaction(req) {
+        const transaction = req.transaction;
+        if (!(transaction instanceof stellar_transactions_ts_1.StellarUnsignedTransaction)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid transaction: ${String(transaction)}, expected StellarUnsignedTransaction.`, { chainId: this.chainId });
+        }
+        const filteredWallets = req.filteredWallets === undefined || req.filteredWallets === null ? null : (0, python_builtins_ts_1.pyStringContainer)(req.filteredWallets);
+        const filteredAssets = req.filteredAssets === undefined || req.filteredAssets === null ? null : [...req.filteredAssets];
+        const envelope = await transaction.buildTransactionEnvelope(this);
+        if (transaction.isSorobanInvokeContractTransaction) {
+            const sim = await (0, stellar_transactions_ts_1.simulateSorobanTransaction)(envelope, this);
+            if (sim.error) {
+                return new stellar_transactions_ts_1.StellarTransactionSimulationResult({
+                    chainId: this.chainId,
+                    statusType: transaction_simulation_ts_1.TransactionSimulationStatusTypes.Failed,
+                    balanceChanges: new Map(),
+                    error: new Error(sim.error),
+                });
+            }
+            if (sim.events === null) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, "'NoneType' object is not iterable", { chainId: this.chainId });
+            }
+            const balanceChanges = await this.getBalanceChangesFromDiagnosisEvents(sim.events.map((event) => stellar_sdk_1.xdr.DiagnosticEvent.fromXDR(event, 'base64')), { filteredWallets, filteredAssets });
+            return new stellar_transactions_ts_1.StellarTransactionSimulationResult({
+                chainId: this.chainId,
+                statusType: transaction_simulation_ts_1.TransactionSimulationStatusTypes.Success,
+                balanceChanges,
+                error: null,
+                fees: sim.minResourceFee !== null
+                    ? new stellar_transactions_ts_1.StellarTransactionFees({
+                        feeStroops: Number(sim.minResourceFee),
+                        feePayer: StellarChain._muxedToClassic(envelope.source),
+                    })
+                    : null,
+            });
+        }
+        try {
+            const balanceChanges = this._balanceChangesFromOperations(envelope, { filteredWallets, filteredAssets });
+            const memo = envelope.memo;
+            const feePayer = StellarChain._muxedToClassic(envelope.source);
+            const feeStroops = Math.trunc(Number(envelope.fee));
+            const fees = new stellar_transactions_ts_1.StellarTransactionFees({ feeStroops, feePayer });
+            transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, feePayer, this._nativeAsset, transaction_status_ts_1.AssetBalanceChange.fromMr(-BigInt(feeStroops), stellar_asset_ts_1.StellarAsset.DECIMALS));
+            return new stellar_transactions_ts_1.StellarTransactionSimulationResult({
+                chainId: this.chainId,
+                statusType: transaction_simulation_ts_1.TransactionSimulationStatusTypes.Success,
+                balanceChanges,
+                error: null,
+                fees,
+                memo,
+            });
+        }
+        catch (err) {
+            return new stellar_transactions_ts_1.StellarTransactionSimulationResult({
+                chainId: this.chainId,
+                statusType: transaction_simulation_ts_1.TransactionSimulationStatusTypes.Failed,
+                balanceChanges: new Map(),
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
+        }
+    }
+    async broadcastSignedTransaction(signedTransaction) {
+        if (!(signedTransaction instanceof stellar_transactions_ts_1.StellarSignedTransaction)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid transaction ${String(signedTransaction)}, expected StellarSignedTransaction.`, { chainId: this.chainId });
+        }
+        if (this.chainId !== signedTransaction.chainId) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid chain for signed transaction with chain id ${signedTransaction.chainId}, expected ${this.chainId}.`, { chainId: this.chainId });
+        }
+        const envelope = (0, stellar_transactions_ts_1.parseSignedStellarEnvelope)(signedTransaction.signedXdr, this.networkPassphrase);
+        try {
+            const response = await this._submitTransaction(envelope);
+            if (response === null || typeof response !== 'object' || !('hash' in response)) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, (0, python_repr_ts_1.pyRepr)('hash'), { chainId: this.chainId, txHash: signedTransaction.txHash });
+            }
+            return new stellar_transactions_ts_1.StellarBroadcastTransactionResponse({ chain: this, txHash: response.hash });
+        }
+        catch (err) {
+            return new stellar_transactions_ts_1.StellarBroadcastTransactionResponse({
+                chain: this,
+                txHash: signedTransaction.txHash,
+                broadcastError: err instanceof Error ? err : new Error(String(err)),
+            });
+        }
+    }
+    static verifySignature(publicKey, message, signedMessage) {
+        if (!(signedMessage instanceof StellarSignedMessage)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `StellarChain expected a StellarSignedMessage, got ${(0, python_repr_ts_1.pyTypeRepr)(signedMessage)}`);
+        }
+        try {
+            return stellar_sdk_1.Keypair.fromPublicKey(String(publicKey)).verify(stellarMessageHash(message), Buffer.from((0, bytes_from_hex_ts_1.bytesFromHex)(signedMessage.signature)));
+        }
+        catch {
+            return false;
+        }
+    }
+    verifySignature(publicKey, message, signedMessage) {
+        return StellarChain.verifySignature(publicKey, message, signedMessage);
+    }
+    async getAccountNextSequence(walletAddress) {
+        const classicAddress = StellarChain.toClassicAccountId(walletAddress);
+        const account = await (0, stellar_transactions_ts_1.loadStellarAccount)(this, classicAddress);
+        return BigInt(account.sequenceNumber()) + 1n;
+    }
+    async getBalance(owner, tokenIdentifier) {
+        const asset = await this.resolveAsset(tokenIdentifier);
+        const balance = await this.getAssetBalance(asset, owner);
+        return (0, transaction_status_ts_1.hrDecimalToMinorUnits)(balance, asset.decimals);
+    }
+    async createTransferUnsignedTransaction(req) {
+        if (!req.from) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'Stellar transfers require an explicit `from` (no implicit signer)', {
+                chainId: this.chainId,
+            });
+        }
+        if (req.isFullBalance === true) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'CreateTransferRequest.isFullBalance is not supported on StellarChain — pass `amount` or `amountHr` explicitly.', { chainId: this.chainId });
+        }
+        const asset = await this.resolveAsset(req.tokenIdentifier);
+        const resolved = (0, chain_base_ts_1.resolveTransferAmount)(req, asset.decimals);
+        if (resolved.kind !== 'exact') {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'Stellar transfers require an explicit amount', { chainId: this.chainId });
+        }
+        const bundle = await this.createTransferTransaction({
+            asset,
+            amountHr: new decimal_js_1.Decimal((0, transaction_status_ts_1.minorUnitsToHrString)(resolved.amountMr, asset.decimals)),
+            senderAddress: req.from,
+            receiverAddress: req.to,
+            memoText: req.memo ?? null,
+            gasPricing: req.gasPricing,
+        });
+        for (const prerequisite of bundle.prerequisites) {
+            if (await this.isPrerequisiteAlreadyMet(prerequisite))
+                continue;
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Stellar transfer to ${req.to} needs a prerequisite the receiver must handle first (${prerequisite.constructor.name}); createTransferUnsignedTransaction cannot return it. Use createTransferTransaction and handle the prerequisite with the receiver's wallet.`, { chainId: this.chainId, address: req.to });
+        }
+        return bundle.transaction;
+    }
+    async isPrerequisiteAlreadyMet(prerequisite) {
+        if (!(prerequisite instanceof stellar_transactions_ts_1.StellarChangeTrustLineTransactionPrerequisite))
+            return false;
+        try {
+            const current = await this.getTrustLineLimit(prerequisite.walletAddress, this.createSacToken(prerequisite.code, prerequisite.issuer));
+            return current.limit.gte(prerequisite.limit);
+        }
+        catch (err) {
+            if (err instanceof stellar_sdk_1.NotFoundError)
+                return false;
+            throw err;
+        }
+    }
+    async broadcast(signed, opts) {
+        if (opts && opts.signal !== undefined) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.FeatureNotSupported, "Stellar broadcast: signal is not honored (silently ignoring would let a caller conclude 'not sent' while the tx still lands)", { chainId: this.chainId });
+        }
+        const signedTransaction = this.parseSignedInput(signed);
+        const response = await this.broadcastSignedTransaction(signedTransaction);
+        const error = response.broadcastError;
+        if (error === null) {
+            const signedHash = signedTransaction.txHash.toLowerCase();
+            if (typeof response.txHash !== 'string' || response.txHash.toLowerCase() !== signedHash) {
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, `Horizon answered hash ${(0, python_repr_ts_1.pyRepr)(response.txHash)} for the signed transaction ${signedTransaction.txHash}`, { chainId: this.chainId, txHash: signedTransaction.txHash });
+            }
+            return signedHash;
+        }
+        const rpcUrl = this.horizonUrl;
+        if (error instanceof stellar_sdk_1.AccountRequiresMemoError) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.BroadcastRejected, `Stellar broadcast refused before submission on ${this.name}: destination ${error.accountId} requires a memo (SEP-29, operation ${error.operationIndex})`, { chainId: this.chainId, txHash: response.txHash, address: error.accountId }, error);
+        }
+        const rejection = horizonSubmissionRejection(error);
+        if (rejection !== null) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.BroadcastRejected, (0, errors_ts_1.sanitizeMessage)(`Stellar broadcast rejected on ${this.name}: ${describeHorizonRejection(rejection, error)}`, rpcUrl), { chainId: this.chainId, txHash: response.txHash }, (0, errors_ts_1.sanitizeCause)(error, rpcUrl));
+        }
+        throw this.rpcError(`Stellar broadcast failed on ${this.name}`, error, response.txHash, rpcUrl);
+    }
+    async getChainTipHeight() {
+        const page = await this.asyncHorizonServer.ledgers().order('desc').limit(1).call();
+        return Number(page.records[0].sequence);
+    }
+    async verifyMessageSignature(req) {
+        try {
+            return StellarChain.verifySignature(req.signer, req.message, new StellarSignedMessage(req.signature));
+        }
+        catch {
+            return false;
+        }
+    }
+    parseSignedInput(signed) {
+        if (typeof signed === 'string') {
+            const trimmed = signed.trim();
+            if (trimmed.startsWith('{')) {
+                const payload = (0, transaction_json_ts_1.coerceJsonDict)(trimmed);
+                if (payload[transaction_json_ts_1.JSON_TRANSACTION_TYPE_KEY] === stellar_transactions_ts_1.StellarSignedTransaction.JSON_TYPE) {
+                    return stellar_transactions_ts_1.StellarSignedTransaction.fromJson(payload);
+                }
+                throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, 'Stellar broadcast: JSON input must be a StellarSignedTransaction payload', {
+                    chainId: this.chainId,
+                });
+            }
+            return new stellar_transactions_ts_1.StellarSignedTransaction({ chainId: this.chainId, signedXdr: trimmed, networkPassphrase: this.networkPassphrase });
+        }
+        return new stellar_transactions_ts_1.StellarSignedTransaction({
+            chainId: this.chainId,
+            signedXdr: Buffer.from(signed).toString('base64'),
+            networkPassphrase: this.networkPassphrase,
+        });
+    }
+    upsertFee(balanceChanges, fees) {
+        if (!fees)
+            return;
+        transaction_status_ts_1.AssetBalanceChange.upsert(balanceChanges, fees.feePayer, this._nativeAsset, transaction_status_ts_1.AssetBalanceChange.fromMr(-BigInt(fees.feeStroops), stellar_asset_ts_1.StellarAsset.DECIMALS));
+    }
+    identifierIndex(assets) {
+        const index = new Map();
+        for (const a of assets) {
+            this.assertStellarAsset(a);
+            if (a.identifier !== undefined)
+                index.set(a.identifier, a);
+        }
+        return index;
+    }
+    assertStellarAsset(asset) {
+        if (!(asset instanceof stellar_asset_ts_1.StellarAsset)) {
+            throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `Invalid asset ${String(asset)} of type ${(0, python_repr_ts_1.pyTypeRepr)(asset)}, expected StellarAsset.`, {
+                chainId: this.chainId,
+            });
+        }
+    }
+    envName() {
+        return this.name.replace(/ /g, '_').toUpperCase();
+    }
+    loadUrlFromEnv(candidates, fallback) {
+        const env = globalThis.process?.env;
+        for (const name of candidates) {
+            const value = env?.[name];
+            if (value)
+                return value;
+        }
+        return fallback;
+    }
+    async soroban(call) {
+        try {
+            return await call;
+        }
+        catch (err) {
+            throw (0, stellar_transactions_ts_1.sorobanRpcError)(err, this.chainId, this.sorobanRpcUrl);
+        }
+    }
+    rpcError(message, err, txHash, rpcUrl) {
+        return new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.RpcError, (0, errors_ts_1.sanitizeMessage)(`${message}: ${err instanceof Error ? err.message : String(err)}`, rpcUrl), { chainId: this.chainId, txHash }, (0, errors_ts_1.sanitizeCause)(err, rpcUrl));
+    }
+}
+exports.StellarChain = StellarChain;
+function scvalToUint32(value) {
+    if (value.switch().name !== 'scvU32') {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Expected an SCV_U32 value, got ${value.switch().name}`);
+    }
+    return value.u32();
+}
+function scvalToUtf8String(value) {
+    if (value.switch().name !== 'scvString') {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Expected an SCV_STRING value, got ${value.switch().name}`);
+    }
+    const raw = value.str();
+    return (0, python_builtins_ts_1.pyDecodeUtf8)(typeof raw === 'string' ? Buffer.from(raw, 'utf8') : Buffer.from(raw));
+}
+function scvalToInt128(value) {
+    if (value.switch().name !== 'scvI128') {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Expected an SCV_I128 value, got ${value.switch().name}`);
+    }
+    return (0, stellar_sdk_1.scValToBigInt)(value);
+}
+const HORIZON_TRANSACTION_REJECTED_STATUS = 400;
+const STELLAR_SDK_GET_TIMEOUT_MS = 11_000;
+const STELLAR_SDK_POST_TIMEOUT_MS = 33_000;
+const AIOHTTP_DEFAULT_TOTAL_TIMEOUT_MS = 300_000;
+const AIOHTTP_MAX_REDIRECTS = 9;
+function applyAiohttpClientLimits(client) {
+    client.interceptors.request.use((config) => {
+        const total = String(config.method).toLowerCase() === 'post' ? STELLAR_SDK_POST_TIMEOUT_MS : STELLAR_SDK_GET_TIMEOUT_MS;
+        return Object.assign(config, { timeout: total, signal: AbortSignal.timeout(total), proxy: false, maxRedirects: AIOHTTP_MAX_REDIRECTS });
+    });
+}
+const GET_TRANSACTION_STATUSES = new Set(['SUCCESS', 'NOT_FOUND', 'FAILED']);
+const GET_TRANSACTION_REQUIRED_INTS = ['latestLedger', 'latestLedgerCloseTime', 'oldestLedger', 'oldestLedgerCloseTime'];
+const GET_TRANSACTION_OPTIONAL_INTS = ['applicationOrder', 'ledger', 'createdAt'];
+const GET_TRANSACTION_OPTIONAL_STRS = ['envelopeXdr', 'resultXdr', 'resultMetaXdr'];
+function isAbsent(value) {
+    return value === undefined || value === null;
+}
+function isGetTransactionEvents(value) {
+    if (isAbsent(value))
+        return true;
+    if (typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const events = value;
+    return ((isAbsent(events.diagnosticEventsXdr) || (0, python_pydantic_ts_1.isPydanticStrList)(events.diagnosticEventsXdr)) &&
+        (isAbsent(events.transactionEventsXdr) || (0, python_pydantic_ts_1.isPydanticStrList)(events.transactionEventsXdr)) &&
+        (isAbsent(events.contractEventsXdr) ||
+            (Array.isArray(events.contractEventsXdr) && events.contractEventsXdr.every((perOperation) => (0, python_pydantic_ts_1.isPydanticStrList)(perOperation)))));
+}
+function isGetTransactionResponse(reply) {
+    if (reply === null || typeof reply !== 'object' || Array.isArray(reply))
+        return false;
+    const fields = reply;
+    return (GET_TRANSACTION_STATUSES.has(fields.status) &&
+        typeof fields.txHash === 'string' &&
+        GET_TRANSACTION_REQUIRED_INTS.every((name) => (0, python_pydantic_ts_1.isPydanticLaxInt)(fields[name])) &&
+        GET_TRANSACTION_OPTIONAL_INTS.every((name) => isAbsent(fields[name]) || (0, python_pydantic_ts_1.isPydanticLaxInt)(fields[name])) &&
+        (isAbsent(fields.feeBump) || (0, python_pydantic_ts_1.isPydanticLaxBool)(fields.feeBump)) &&
+        GET_TRANSACTION_OPTIONAL_STRS.every((name) => isAbsent(fields[name]) || typeof fields[name] === 'string') &&
+        isGetTransactionEvents(fields.events));
+}
+function firstHostFunctionResult(results) {
+    if (results === null)
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.SimulationFailed, "'NoneType' object is not subscriptable");
+    if (results.length === 0)
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.SimulationFailed, 'list index out of range');
+    return stellar_sdk_1.xdr.ScVal.fromXDR(results[0].xdr, 'base64');
+}
+const MEMO_REQUIRED_OPERATION_TYPES = new Set(['payment', 'accountMerge', 'pathPaymentStrictSend', 'pathPaymentStrictReceive']);
+const MEMO_REQUIRED_CONFIG_KEY = 'config.memo_required';
+const MEMO_REQUIRED_CONFIG_VALUE = 'MQ==';
+function transactionXdrOperations(tx) {
+    const envelope = tx.toEnvelope();
+    return envelope.switch().name === 'envelopeTypeTxV0' ? envelope.v0().tx().operations() : envelope.v1().tx().operations();
+}
+function horizonSubmissionRejection(error) {
+    const response = error.response;
+    if (typeof response !== 'object' || response === null)
+        return null;
+    const problem = error instanceof stellar_sdk_1.BadResponseError
+        ? response
+        : response.data;
+    const status = error instanceof stellar_sdk_1.BadResponseError ? problem?.status : response.status;
+    if (status !== HORIZON_TRANSACTION_REJECTED_STATUS)
+        return null;
+    return typeof problem === 'object' && problem !== null ? problem : {};
+}
+function describeHorizonRejection(problem, error) {
+    const resultCodes = problem.extras?.result_codes;
+    return resultCodes !== undefined ? JSON.stringify(resultCodes) : error.message;
+}
+async function runBatch(items, fetchOne) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    let aborted = false;
+    const spawn = async () => {
+        while (!aborted) {
+            const idx = cursor++;
+            if (idx >= items.length)
+                return;
+            try {
+                results[idx] = await fetchOne(items[idx]);
+            }
+            catch (err) {
+                aborted = true;
+                throw err;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(8, items.length) }, spawn));
+    return results;
+}
+//# sourceMappingURL=stellar_chain.js.map