@layerswap/wallet-stellar 2.1.0

package/dist/esm/service/stellarKitManager.js

@@ -0,0 +1,272 @@
+import { ActionMessageType } from '@layerswap/widget-types';
+import { AppSettings, isMobile, isValidStellarAddress } from '@layerswap/utils';
+import { STELLAR_SESSION_KEY } from '../constants';
+import { STELLAR_APPKIT_WALLET_CONNECT_ID, STELLAR_WALLET_CONNECT_ID, StellarWalletConnectChain, StellarWalletConnectModule, } from './StellarWalletConnectModule';
+import { stellarStore } from './stellarStore';
+const STELLAR_APPKIT_WALLET_CONNECT_STORAGE_PREFIX = 'layerswapStellarAppKitWalletConnect';
+function readPersistedSession() {
+    if (typeof window === 'undefined')
+        return undefined;
+    try {
+        const raw = window.localStorage.getItem(STELLAR_SESSION_KEY);
+        if (!raw)
+            return undefined;
+        const value = JSON.parse(raw);
+        if (typeof value.walletId === 'string'
+            && typeof value.address === 'string'
+            && value.address.startsWith('G')
+            && isValidStellarAddress(value.address)) {
+            return { walletId: value.walletId, address: value.address };
+        }
+    }
+    catch {
+        // Storage is optional; an unavailable/corrupt session is ignored.
+    }
+    return undefined;
+}
+function persistSession(session) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        if (session) {
+            window.localStorage.setItem(STELLAR_SESSION_KEY, JSON.stringify(session));
+        }
+        else {
+            window.localStorage.removeItem(STELLAR_SESSION_KEY);
+        }
+    }
+    catch {
+        // Wallet state still works when storage is unavailable.
+    }
+}
+function toSnapshot(wallet) {
+    return {
+        id: wallet.id,
+        name: wallet.name,
+        type: wallet.type,
+        isAvailable: wallet.isAvailable,
+        isPlatformWrapper: wallet.isPlatformWrapper,
+        icon: wallet.icon,
+        url: wallet.url,
+    };
+}
+function walletError(name, message) {
+    const error = new Error(message);
+    error.name = name;
+    return error;
+}
+class StellarKitManager {
+    constructor() {
+        this.detachers = [];
+        this.generation = 0;
+    }
+    init(walletConnect) {
+        if (typeof window === 'undefined')
+            return Promise.resolve();
+        if (this.initPromise)
+            return this.initPromise;
+        const generation = ++this.generation;
+        stellarStore.getState().setInitializing();
+        this.initPromise = this.initialize(walletConnect, generation).catch(error => {
+            const message = error instanceof Error ? error.message : String(error);
+            if (generation === this.generation)
+                stellarStore.getState().setReady(message);
+            throw error;
+        });
+        return this.initPromise;
+    }
+    async initialize(walletConnect, generation) {
+        const kitPromise = import('@creit.tech/stellar-wallets-kit/sdk');
+        const kitTypesPromise = import('@creit.tech/stellar-wallets-kit/types');
+        const kitUtilsPromise = import('@creit.tech/stellar-wallets-kit/modules/utils');
+        const [kitModule, kitTypesModule, kitUtilsModule] = await Promise.all([
+            kitPromise,
+            kitTypesPromise,
+            kitUtilsPromise,
+        ]);
+        if (generation !== this.generation)
+            return;
+        const isTestnet = AppSettings.ApiVersion === 'testnet' || AppSettings.ApiVersion === 'sandbox';
+        const network = isTestnet ? kitTypesModule.Networks.TESTNET : kitTypesModule.Networks.PUBLIC;
+        const modules = kitUtilsModule.defaultModules();
+        if (walletConnect?.projectId) {
+            this.walletConnectModule = new StellarWalletConnectModule(walletConnect, undefined, [isTestnet ? StellarWalletConnectChain.Testnet : StellarWalletConnectChain.Public,]);
+            modules.push(this.walletConnectModule);
+            this.detachers.push(this.walletConnectModule.onSessionDelete(() => this.clearSession()));
+            if (isMobile()) {
+                const { WalletConnectModule, WalletConnectTargetChain } = await import('@creit.tech/stellar-wallets-kit/modules/wallet-connect');
+                if (generation !== this.generation)
+                    return;
+                const appKitModule = new WalletConnectModule({
+                    projectId: walletConnect.projectId,
+                    metadata: { name: walletConnect.name, description: walletConnect.description, url: walletConnect.url, icons: walletConnect.icons, },
+                    signClientOptions: { customStoragePrefix: STELLAR_APPKIT_WALLET_CONNECT_STORAGE_PREFIX },
+                    allowedChains: [isTestnet ? WalletConnectTargetChain.TESTNET : WalletConnectTargetChain.PUBLIC],
+                });
+                appKitModule.productId = STELLAR_APPKIT_WALLET_CONNECT_ID;
+                this.appKitWalletConnectModule = appKitModule;
+                modules.push(appKitModule);
+            }
+        }
+        const persisted = readPersistedSession();
+        kitModule.StellarWalletsKit.init({
+            modules,
+            selectedWalletId: persisted?.walletId,
+            network,
+        });
+        this.kit = kitModule.StellarWalletsKit;
+        this.networks = kitTypesModule.Networks;
+        this.network = network;
+        this.attachEvents(kitModule, kitTypesModule);
+        const wallets = await this.kit.refreshSupportedWallets();
+        if (generation !== this.generation)
+            return;
+        stellarStore.getState().setWallets(wallets.map(toSnapshot));
+        if (persisted && wallets.some(wallet => wallet.id === persisted.walletId)) {
+            this.selectedWalletId = persisted.walletId;
+            this.kit.setWallet(persisted.walletId);
+            stellarStore.getState().setActive(persisted.walletId, persisted.address);
+        }
+        else if (persisted) {
+            persistSession(undefined);
+        }
+        stellarStore.getState().setReady();
+    }
+    attachEvents(kitModule, kitTypesModule) {
+        const kit = kitModule.StellarWalletsKit;
+        this.detachers.push(kit.on(kitTypesModule.KitEventType.STATE_UPDATED, event => {
+            stellarStore.getState().setNetworkPassphrase(event.payload.networkPassphrase || undefined);
+            const address = event.payload.address;
+            const walletId = this.selectedWalletId ?? stellarStore.getState().activeWalletId;
+            if (walletId && address?.startsWith('G') && isValidStellarAddress(address)) {
+                stellarStore.getState().setActive(walletId, address);
+                persistSession({ walletId, address });
+            }
+        }), kit.on(kitTypesModule.KitEventType.WALLET_SELECTED, event => {
+            this.selectedWalletId = event.payload.id;
+        }), kit.on(kitTypesModule.KitEventType.DISCONNECT, () => this.clearSession()));
+    }
+    async connect(walletId) {
+        await this.requireReady();
+        const kit = this.requireKit();
+        const previousWalletId = stellarStore.getState().activeWalletId;
+        try {
+            this.selectedWalletId = walletId;
+            kit.setWallet(walletId);
+            const { address } = await kit.fetchAddress();
+            this.assertSourceAddress(address);
+            if (this.network)
+                await this.assertWalletNetwork(this.network);
+            stellarStore.getState().setActive(walletId, address);
+            persistSession({ walletId, address });
+            return { address };
+        }
+        catch (error) {
+            this.selectedWalletId = previousWalletId;
+            if (previousWalletId)
+                kit.setWallet(previousWalletId);
+            throw error instanceof Error ? error : new Error(error.message);
+        }
+    }
+    onDisplayUri(listener) {
+        return this.walletConnectModule?.onDisplayUri(listener) ?? (() => { });
+    }
+    warmUpWalletConnect() {
+        this.walletConnectModule?.warmup();
+    }
+    async revalidate(expectedAddress, networkPassphrase) {
+        await this.requireReady();
+        const kit = this.requireKit();
+        const { activeWalletId } = stellarStore.getState();
+        if (!activeWalletId) {
+            throw walletError(ActionMessageType.WaletMismatch, 'Stellar wallet is not connected');
+        }
+        this.selectedWalletId = activeWalletId;
+        kit.setWallet(activeWalletId);
+        await this.assertWalletNetwork(networkPassphrase);
+        const { address } = activeWalletId === STELLAR_WALLET_CONNECT_ID && this.walletConnectModule
+            ? await this.walletConnectModule.getConnectedAddress(expectedAddress)
+            : activeWalletId === STELLAR_APPKIT_WALLET_CONNECT_ID && this.appKitWalletConnectModule
+                ? await this.getAppKitConnectedAddress(this.appKitWalletConnectModule, expectedAddress)
+                : await kit.fetchAddress().catch((error) => { throw new Error(error.message); });
+        this.assertSourceAddress(address);
+        if (address !== expectedAddress) {
+            throw walletError(ActionMessageType.WaletMismatch, 'The connected Stellar account changed');
+        }
+        stellarStore.getState().setActive(activeWalletId, address);
+        persistSession({ walletId: activeWalletId, address });
+    }
+    async signTransaction(xdr, networkPassphrase, address) {
+        const kit = this.requireKit();
+        const networks = this.networks;
+        if (networks) {
+            const knownNetwork = Object.values(networks).find(value => value === networkPassphrase);
+            if (knownNetwork)
+                kit.setNetwork(knownNetwork);
+        }
+        return kit.signTransaction(xdr, { networkPassphrase, address })
+            .catch((error) => { throw new Error(error.message); });
+    }
+    async refreshWallets() {
+        await this.requireReady();
+        const wallets = await this.requireKit().refreshSupportedWallets();
+        stellarStore.getState().setWallets(wallets.map(toSnapshot));
+    }
+    async disconnect() {
+        try {
+            await this.kit?.disconnect();
+        }
+        finally {
+            this.clearSession();
+        }
+    }
+    dispose() {
+        this.generation += 1;
+        for (const detach of this.detachers.splice(0))
+            detach();
+        this.walletConnectModule?.dispose();
+        this.walletConnectModule = undefined;
+        this.appKitWalletConnectModule = undefined;
+        this.kit = undefined;
+        this.networks = undefined;
+        this.initPromise = undefined;
+        this.selectedWalletId = undefined;
+    }
+    async requireReady() {
+        if (!this.initPromise)
+            throw new Error('Stellar Wallets Kit is not initialized');
+        await this.initPromise;
+    }
+    requireKit() {
+        if (!this.kit)
+            throw new Error('Stellar Wallets Kit is not initialized');
+        return this.kit;
+    }
+    async assertWalletNetwork(expected) {
+        const walletNetwork = await this.requireKit().getNetwork().catch(() => undefined);
+        if (walletNetwork?.networkPassphrase && walletNetwork.networkPassphrase !== expected) {
+            const target = expected === this.networks?.TESTNET ? 'Testnet' : 'Mainnet';
+            throw walletError(ActionMessageType.WaletMismatch, `The wallet is on the wrong network. Switch it to Stellar ${target}, then try again`);
+        }
+    }
+    async getAppKitConnectedAddress(module, expectedAddress) {
+        const sessions = await module.getSessions();
+        const connected = sessions.some(session => (session.namespaces['stellar']?.accounts ?? []).some(account => account.split(':')[2] === expectedAddress));
+        if (!connected) {
+            throw new Error('The Stellar WalletConnect session expired; reconnect the wallet');
+        }
+        return { address: expectedAddress };
+    }
+    assertSourceAddress(address) {
+        if (!address.startsWith('G') || !isValidStellarAddress(address)) {
+            throw new Error('The selected wallet did not return a valid Stellar G-address');
+        }
+    }
+    clearSession() {
+        persistSession(undefined);
+        this.selectedWalletId = undefined;
+        stellarStore.getState().setActive(undefined, undefined);
+        stellarStore.getState().setNetworkPassphrase(undefined);
+    }
+}
+export const stellarKitManager = new StellarKitManager();

package/dist/esm/service/stellarStore.js

@@ -0,0 +1,14 @@
+import { createStore } from 'zustand/vanilla';
+export const stellarStore = createStore()((set) => ({
+    wallets: [],
+    activeWalletId: undefined,
+    activeAddress: undefined,
+    networkPassphrase: undefined,
+    ready: false,
+    error: undefined,
+    setWallets: wallets => set({ wallets }),
+    setActive: (activeWalletId, activeAddress) => set({ activeWalletId, activeAddress }),
+    setNetworkPassphrase: networkPassphrase => set({ networkPassphrase }),
+    setInitializing: () => set({ ready: false, error: undefined }),
+    setReady: error => set({ ready: true, error }),
+}));

package/dist/esm/stellarBalanceProvider.js

@@ -0,0 +1,49 @@
+import { BalanceProvider, insertIfNotExists } from '@layerswap/widget-types';
+import { NetworkType } from '@layerswap/widget-types';
+import { createStellarZeroBalance, createUnfundedStellarBalances, resolveStellarBalanceAmount, } from './stellarBalances';
+import { resolveStellarAsset, resolveStellarNetworkPassphrase } from './stellarNetwork';
+import { getStellarHorizonServer } from './stellarServers';
+function statusOf(error) {
+    const candidate = error;
+    return candidate?.status ?? candidate?.response?.status ?? candidate?.cause?.status ?? candidate?.cause?.response?.status;
+}
+export class StellarBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = network => network.type === NetworkType.Stellar;
+        this.fetchBalance = async (address, network) => {
+            const tokens = insertIfNotExists(network.tokens, network.token);
+            try {
+                const networkPassphrase = resolveStellarNetworkPassphrase(network);
+                const server = await getStellarHorizonServer(network, networkPassphrase);
+                const needsReserve = tokens.some(token => resolveStellarAsset(token).isNative());
+                const [account, ledgerPage] = await Promise.all([
+                    server.loadAccount(address),
+                    needsReserve ? server.ledgers().order('desc').limit(1).call() : Promise.resolve(undefined),
+                ]);
+                const baseReserveInStroops = ledgerPage?.records[0]?.base_reserve_in_stroops;
+                if (needsReserve && !Number.isSafeInteger(baseReserveInStroops)) {
+                    throw new Error('Horizon returned an invalid Stellar base reserve');
+                }
+                return tokens.map(token => {
+                    try {
+                        return {
+                            ...createStellarZeroBalance(token, network),
+                            amount: resolveStellarBalanceAmount(token, account.balances, resolveStellarAsset(token).isNative()
+                                ? { account, baseReserveInStroops: baseReserveInStroops }
+                                : undefined),
+                        };
+                    }
+                    catch (error) {
+                        return this.resolveTokenBalanceFetchError(error, token, network);
+                    }
+                });
+            }
+            catch (error) {
+                if (statusOf(error) === 404)
+                    return createUnfundedStellarBalances(tokens, network);
+                return tokens.map(token => this.resolveTokenBalanceFetchError(error, token, network));
+            }
+        };
+    }
+}

package/dist/esm/stellarBalances.js

@@ -0,0 +1,40 @@
+import { baseUnitsToNumber } from '@layerswap/utils/common';
+import { resolveStellarAsset } from './stellarNetwork';
+export function createStellarZeroBalance(token, network) {
+    const asset = resolveStellarAsset(token);
+    return {
+        network: network.name,
+        token: token.symbol,
+        amount: 0,
+        request_time: new Date().toJSON(),
+        decimals: token.decimals,
+        isNativeCurrency: asset.isNative(),
+    };
+}
+export function resolveStellarBalanceAmount(token, balances, reserve) {
+    const asset = resolveStellarAsset(token);
+    const line = asset.isNative()
+        ? balances.find(balance => balance.asset_type === 'native')
+        : balances.find(balance => (balance.asset_type === asset.getAssetType()
+            && balance.asset_code === asset.getCode()
+            && balance.asset_issuer === asset.getIssuer()));
+    if (!line)
+        return 0;
+    if (!asset.isNative() && line.is_authorized !== true) {
+        throw new Error(`The ${token.symbol} trustline is not authorized`);
+    }
+    let spendable = Number(line.balance) - Number(line.selling_liabilities ?? 0);
+    if (asset.isNative()) {
+        if (!reserve)
+            throw new Error('Stellar base reserve is unavailable');
+        const { account, baseReserveInStroops } = reserve;
+        const reserveUnits = 2 + account.subentry_count + account.num_sponsoring - account.num_sponsored;
+        spendable -= reserveUnits * baseUnitsToNumber(BigInt(baseReserveInStroops), token.decimals);
+    }
+    if (!Number.isFinite(spendable))
+        throw new Error(`Horizon returned an invalid ${token.symbol} balance`);
+    return Math.max(0, spendable);
+}
+export function createUnfundedStellarBalances(tokens, network) {
+    return tokens.map(token => createStellarZeroBalance(token, network));
+}

package/dist/esm/stellarGasProvider.js

@@ -0,0 +1,22 @@
+import { baseUnitsToNumber } from '@layerswap/utils/common';
+import { NetworkType } from '@layerswap/widget-types';
+import { resolveStellarNetworkPassphrase } from './stellarNetwork';
+import { getStellarHorizonServer } from './stellarServers';
+export class StellarGasProvider {
+    constructor() {
+        this.supportsNetwork = network => network.type === NetworkType.Stellar;
+    }
+    async getGas({ network }) {
+        if (!network.token)
+            throw new Error('Stellar network token is missing');
+        const networkPassphrase = resolveStellarNetworkPassphrase(network);
+        const server = await getStellarHorizonServer(network, networkPassphrase);
+        const feeInStroops = await server.fetchBaseFee();
+        if (!Number.isSafeInteger(feeInStroops) || feeInStroops < 0)
+            throw new Error('Invalid Stellar fee');
+        return {
+            gas: baseUnitsToNumber(BigInt(feeInStroops), network.token.decimals),
+            token: network.token,
+        };
+    }
+}

package/dist/esm/stellarNetwork.js

@@ -0,0 +1,34 @@
+import { Asset, StrKey } from '@stellar/stellar-sdk';
+export const STELLAR_PUBLIC_PASSPHRASE = 'Public Global Stellar Network ; September 2015';
+export const STELLAR_TESTNET_PASSPHRASE = 'Test SDF Network ; September 2015';
+export function resolveStellarNetworkPassphrase(network) {
+    const expected = network.name === 'STELLAR_MAINNET'
+        ? STELLAR_PUBLIC_PASSPHRASE
+        : network.name === 'STELLAR_TESTNET'
+            ? STELLAR_TESTNET_PASSPHRASE
+            : undefined;
+    const configured = network.chain_id;
+    if (!expected)
+        throw new Error(`Unsupported Stellar network: ${network.name}`);
+    if (!configured)
+        throw new Error('Stellar network passphrase is missing from chain_id');
+    if (configured !== expected)
+        throw new Error('Stellar network passphrase does not match the network ID');
+    return configured;
+}
+export function resolveStellarAsset(token) {
+    if (token.decimals !== 7)
+        throw new Error(`Stellar assets must use 7 decimals: ${token.symbol}`);
+    if (!token.contract) {
+        if (token.symbol !== 'XLM')
+            throw new Error(`Unsupported native Stellar asset: ${token.symbol}`);
+        return Asset.native();
+    }
+    if (token.symbol.length < 1 || token.symbol.length > 12 || !/^[a-zA-Z0-9]+$/.test(token.symbol)) {
+        throw new Error(`Stellar issued-asset code is invalid: ${token.symbol}`);
+    }
+    if (!StrKey.isValidEd25519PublicKey(token.contract)) {
+        throw new Error(`Stellar issued-asset issuer is invalid: ${token.symbol}`);
+    }
+    return new Asset(token.symbol, token.contract);
+}

package/dist/esm/stellarServers.js

@@ -0,0 +1,51 @@
+import { Horizon, rpc } from '@stellar/stellar-sdk';
+const horizonServers = new Map();
+const rpcServers = new Map();
+function getCandidateUrls(network) {
+    return [...new Set([network.node_url, ...(network.nodes ?? [])].filter(Boolean))];
+}
+async function findServer(network, networkPassphrase, kind, createAndVerify) {
+    const candidates = getCandidateUrls(network);
+    if (candidates.length === 0) {
+        throw new Error(`No Stellar ${kind} endpoints are configured for ${network.name}`);
+    }
+    const results = await Promise.allSettled(candidates.map(createAndVerify));
+    const match = results.find(result => result.status === 'fulfilled');
+    if (match?.status === 'fulfilled')
+        return match.value;
+    const cause = results.find((result) => result.status === 'rejected')?.reason;
+    throw new Error(`No Stellar ${kind} endpoint for ${network.name} matches ${networkPassphrase}`, { cause });
+}
+function cachedServer(cache, key, load) {
+    const existing = cache.get(key);
+    if (existing)
+        return existing;
+    const pending = load().catch(error => {
+        cache.delete(key);
+        throw error;
+    });
+    cache.set(key, pending);
+    return pending;
+}
+export function getStellarHorizonServer(network, networkPassphrase) {
+    const key = `${network.name}:${networkPassphrase}:${getCandidateUrls(network).join('|')}`;
+    return cachedServer(horizonServers, key, () => findServer(network, networkPassphrase, 'Horizon', async (url) => {
+        const server = new Horizon.Server(url);
+        const root = await server.root();
+        if (root.network_passphrase !== networkPassphrase) {
+            throw new Error(`Horizon endpoint ${url} is connected to a different Stellar network`);
+        }
+        return server;
+    }));
+}
+export function getStellarRpcServer(network, networkPassphrase) {
+    const key = `${network.name}:${networkPassphrase}:${getCandidateUrls(network).join('|')}`;
+    return cachedServer(rpcServers, key, () => findServer(network, networkPassphrase, 'RPC', async (url) => {
+        const server = new rpc.Server(url);
+        const rpcNetwork = await server.getNetwork();
+        if (rpcNetwork.passphrase !== networkPassphrase) {
+            throw new Error(`RPC endpoint ${url} is connected to a different Stellar network`);
+        }
+        return server;
+    }));
+}

package/dist/esm/transferProvider/createStellarTransfer.js

@@ -0,0 +1,122 @@
+import { Transaction, TransactionBuilder, TransactionFailedError } from '@stellar/stellar-sdk';
+import { bytesToHex } from '@layerswap/utils/common';
+import { foregroundWalletApp } from '@layerswap/wallet-core';
+import { ActionMessageType, NetworkType } from '@layerswap/widget-types';
+import { resolveStellarNetworkPassphrase } from '../stellarNetwork';
+import { getStellarHorizonServer, getStellarRpcServer } from '../stellarServers';
+import { stellarKitManager } from '../service/stellarKitManager';
+import { buildStellarDepositOperation, validateStellarXdr } from './validateStellarXdr';
+const TRANSACTION_TIMEOUT_SECONDS = 5 * 60;
+function mappedError(name, message, cause) {
+    const error = new Error(message, cause === undefined ? undefined : { cause });
+    error.name = name;
+    return error;
+}
+function isWalletRejection(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /reject|declin|cancel|denied|closed/i.test(message);
+}
+function classifyTransferError(error) {
+    if (error instanceof Error && Object.values(ActionMessageType).includes(error.name))
+        return error;
+    if (isWalletRejection(error)) {
+        return mappedError(ActionMessageType.TransactionRejected, 'The Stellar transaction was rejected', error);
+    }
+    if (error instanceof TransactionFailedError) {
+        const resultCodes = error.getResultCodes();
+        if (resultCodes.transaction === 'tx_insufficient_balance'
+            || resultCodes.operations.some(code => code === 'op_underfunded' || code === 'op_low_reserve')) {
+            return mappedError(ActionMessageType.InsufficientFunds, 'Insufficient Stellar balance or reserve', error);
+        }
+        if (resultCodes.transaction === 'tx_bad_seq' || resultCodes.transaction === 'tx_too_late') {
+            // This failure happened after the user signed. Never classify it as
+            // a preflight expiry: the widget retries only unsigned stale actions.
+            return mappedError(ActionMessageType.TransactionFailed, 'The signed Stellar transaction became stale', error);
+        }
+        return mappedError(ActionMessageType.TransactionFailed, 'Horizon rejected the Stellar transaction', error);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return mappedError(ActionMessageType.UnexpectedErrorMessage, message || 'Stellar transaction failed', error);
+}
+export function createStellarTransfer() {
+    return {
+        supportsNetwork: network => network.type === NetworkType.Stellar,
+        async executeTransfer(params) {
+            const { selectedWallet, depositAddress, network, token, amountInBaseUnits, encodedArgs, sequenceNumber, } = params;
+            if (!selectedWallet?.address)
+                throw new Error('Stellar wallet address not found');
+            if (!depositAddress)
+                throw new Error('Stellar depository contract not found');
+            if (!amountInBaseUnits)
+                throw new Error('Stellar deposit amount is missing');
+            if (!encodedArgs)
+                throw new Error('Stellar deposit encoded_args are missing');
+            if (sequenceNumber === undefined)
+                throw new Error('Stellar swap sequence number is missing');
+            try {
+                const networkPassphrase = resolveStellarNetworkPassphrase(network);
+                const operation = buildStellarDepositOperation({
+                    networkPassphrase,
+                    selectedAddress: selectedWallet.address,
+                    depositoryContract: depositAddress,
+                    token,
+                    amountInBaseUnits,
+                    encodedArgs,
+                    swapSequenceNumber: sequenceNumber,
+                });
+                const [horizonServer, rpcServer] = await Promise.all([
+                    getStellarHorizonServer(network, networkPassphrase),
+                    getStellarRpcServer(network, networkPassphrase),
+                ]);
+                const [account, baseFee] = await Promise.all([
+                    horizonServer.loadAccount(selectedWallet.address),
+                    horizonServer.fetchBaseFee(),
+                ]);
+                if (!Number.isSafeInteger(baseFee) || baseFee <= 0) {
+                    throw new Error('Horizon returned an invalid Stellar base fee');
+                }
+                const currentAccountSequence = account.sequence;
+                const preparedTransaction = await rpcServer.prepareTransaction(new TransactionBuilder(account, {
+                    fee: baseFee.toString(),
+                    networkPassphrase,
+                })
+                    .addOperation(operation)
+                    .setTimeout(TRANSACTION_TIMEOUT_SECONDS)
+                    .build());
+                const preparedXdr = preparedTransaction.toXdr();
+                const unsignedTransaction = validateStellarXdr({
+                    envelopeXdr: preparedXdr,
+                    networkPassphrase,
+                    selectedAddress: selectedWallet.address,
+                    depositoryContract: depositAddress,
+                    token,
+                    amountInBaseUnits,
+                    encodedArgs,
+                    swapSequenceNumber: sequenceNumber,
+                    currentAccountSequence,
+                });
+                await stellarKitManager.revalidate(selectedWallet.address, networkPassphrase);
+                await foregroundWalletApp(selectedWallet.metadata?.deepLink);
+                const signed = await stellarKitManager.signTransaction(preparedXdr, networkPassphrase, selectedWallet.address);
+                if (signed.signerAddress && signed.signerAddress !== selectedWallet.address) {
+                    throw mappedError(ActionMessageType.WaletMismatch, 'The Stellar wallet signed with a different account');
+                }
+                const signedTransaction = TransactionBuilder.fromXdr(signed.signedTxXdr, networkPassphrase);
+                if (!(signedTransaction instanceof Transaction))
+                    throw new Error('Wallet returned an unsupported fee-bump transaction');
+                if (signedTransaction.signatures.length === 0)
+                    throw new Error('Wallet returned a Stellar transaction without a signature');
+                if (bytesToHex(signedTransaction.hash()) !== bytesToHex(unsignedTransaction.hash())) {
+                    throw new Error('Wallet changed the Stellar transaction while signing');
+                }
+                const result = await horizonServer.submitTransaction(signedTransaction);
+                if (!result.successful || !result.hash)
+                    throw new Error('Horizon did not accept the Stellar transaction');
+                return result.hash;
+            }
+            catch (error) {
+                throw classifyTransferError(error);
+            }
+        },
+    };
+}