@dynamic-labs-sdk/stellar 1.14.0 → 1.17.0

package/dist/index.esm.js

@@ -1,9 +1,14 @@
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
-import { BaseError } from "@dynamic-labs-sdk/client";
+import { BaseError, InvalidParamError, assertWalletAccountSigningAvailability, getActiveNetworkData, getDefaultClient } from "@dynamic-labs-sdk/client";
+import { WalletProviderPriority, assertDefined, createBaseNetworkProvider, createWalletProviderEventEmitter, formatWalletProviderGroupKey, formatWalletProviderKey, getBuffer, getCore, getDefaultClient as getDefaultClient$1, getNetworkProviderBuilderRegistry, getWalletProviderFromWalletAccount, getWalletProviderRegistry, hasExtension, registerExtension } from "@dynamic-labs-sdk/client/core";
+import { WatchWalletChanges, getNetwork, isConnected, requestAccess, signMessage, signTransaction as signTransaction$1 } from "@stellar/freighter-api";
+import { getPublicKey, isConnected as isConnected$1, signMessage as signMessage$1, signTransaction as signTransaction$2 } from "@lobstrco/signer-extension-api";
+import { Asset, BASE_FEE, Horizon, Operation, TransactionBuilder, hash } from "@stellar/stellar-sdk";
+import { WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
 
 //#region package.json
 var name = "@dynamic-labs-sdk/stellar";
-var version = "1.14.0";
+var version = "1.17.0";
 
 //#endregion
 //#region src/errors/NotStellarProviderError/NotStellarProviderError.ts
@@ -34,10 +39,726 @@ const isStellarWalletAccount = (walletAccount) => {
 	return walletAccount.chain === "STELLAR";
 };
 
+//#endregion
+//#region src/errors/FetchStellarBalanceError/FetchStellarBalanceError.ts
+var FetchStellarBalanceError = class extends BaseError {
+	address;
+	constructor(params) {
+		super({
+			cause: params.cause ?? null,
+			code: "fetch_stellar_balance_error",
+			docsUrl: null,
+			name: "FetchStellarBalanceError",
+			shortMessage: `Failed to fetch Stellar balance for address ${params.address}`
+		});
+		this.address = params.address;
+	}
+};
+
+//#endregion
+//#region src/utils/fetchStellarBalance/fetchStellarBalance.ts
+/**
+* Fetches the native XLM balance for an address from Horizon.
+* Returns '0' when the account has no native balance, and throws a
+* FetchStellarBalanceError when the balance cannot be retrieved.
+*
+* @param address - The Stellar public key.
+* @param networkData - Network data carrying the Horizon RPC URL.
+* @notInstrumented
+*/
+const fetchStellarBalance = async ({ address, networkData }) => {
+	const server = new Horizon.Server(networkData.rpcUrls.http[0]);
+	try {
+		const nativeBalance = (await server.loadAccount(address)).balances.find((balance) => balance.asset_type === "native");
+		if (!nativeBalance || !("balance" in nativeBalance)) return "0";
+		return Number(nativeBalance.balance).toString();
+	} catch (error) {
+		throw new FetchStellarBalanceError({
+			address,
+			cause: error instanceof Error ? error : null
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/createStellarNetworkProvider/createStellarNetworkProvider.ts
+/**
+* Creates a Stellar network provider from network data.
+*
+* @param networkData - The network data for the Stellar network.
+* @notInstrumented
+*/
+const createStellarNetworkProvider = (networkData) => ({
+	...createBaseNetworkProvider("STELLAR", networkData),
+	cluster: networkData.cluster,
+	getBalance: async ({ address }) => ({ balance: await fetchStellarBalance({
+		address,
+		networkData
+	}) })
+});
+
+//#endregion
+//#region src/registerStellarNetworkProviderBuilder/registerStellarNetworkProviderBuilder.ts
+/**
+* Registers the Stellar network provider builder on the client (idempotent).
+*
+* @param client - The Dynamic client instance.
+* @notInstrumented
+*/
+const registerStellarNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+	if (networkProviderBuilderRegistry.get().get("STELLAR")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createStellarNetworkProvider,
+		chain: "STELLAR"
+	});
+};
+
+//#endregion
+//#region src/injected/utils/createFreighterProvider/createFreighterProvider.ts
+/**
+* Freighter Wallet provider adapter that implements IStellarProvider
+* using the Freighter API.
+*
+* @notInstrumented
+*/
+const createFreighterProvider = () => {
+	let watcher;
+	const eventCallbacks = /* @__PURE__ */ new Map();
+	let isWatcherStarted = false;
+	const startWatcher = () => {
+		if (isWatcherStarted) return;
+		if (!watcher) watcher = new WatchWalletChanges();
+		watcher.watch((params) => {
+			const accountChangedCallbacks = eventCallbacks.get("accountChanged");
+			const networkChangedCallbacks = eventCallbacks.get("networkChanged");
+			if (accountChangedCallbacks && params.address !== void 0) accountChangedCallbacks.forEach((callback) => {
+				callback(params.address);
+			});
+			if (networkChangedCallbacks && params.network !== void 0) networkChangedCallbacks.forEach((callback) => {
+				callback(params.network);
+			});
+		});
+		isWatcherStarted = true;
+	};
+	return {
+		close: () => {
+			watcher?.stop();
+			watcher = void 0;
+			eventCallbacks.clear();
+			isWatcherStarted = false;
+		},
+		connect: async () => {
+			return (await requestAccess()).address ?? "";
+		},
+		disconnect: async () => void 0,
+		getNetwork: async () => {
+			return (await getNetwork()).network ?? "PUBLIC";
+		},
+		isUnlocked: async () => {
+			return (await isConnected()).isConnected ?? false;
+		},
+		on: ({ event, callback }) => {
+			if (!eventCallbacks.has(event)) eventCallbacks.set(event, /* @__PURE__ */ new Set());
+			eventCallbacks.get(event).add(callback);
+			startWatcher();
+		},
+		sign: async ({ transactionXdr, options }) => {
+			return (await signTransaction$1(transactionXdr, { networkPassphrase: options?.networkPassphrase })).signedTxXdr ?? "";
+		},
+		signMessage: async ({ message }) => {
+			const response = await signMessage(message);
+			return String(response.signedMessage ?? "");
+		}
+	};
+};
+
+//#endregion
+//#region src/injected/utils/createLobstrProvider/createLobstrProvider.ts
+/**
+* Lobstr Wallet provider adapter that implements IStellarProvider
+* using the Lobstr signer extension API.
+*
+* @notInstrumented
+*/
+const createLobstrProvider = () => ({
+	connect: async () => {
+		return await getPublicKey() ?? "";
+	},
+	getNetwork: async () => "PUBLIC",
+	isUnlocked: async () => isConnected$1(),
+	sign: async ({ transactionXdr }) => {
+		return await signTransaction$2(transactionXdr);
+	},
+	signMessage: async ({ message }) => {
+		return (await signMessage$1(message))?.signedMessage ?? "";
+	}
+});
+
+//#endregion
+//#region src/errors/NotOneKeyProviderError/NotOneKeyProviderError.ts
+var NotOneKeyProviderError = class extends BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "not_onekey_provider_error",
+			docsUrl: null,
+			name: "NotOneKeyProviderError",
+			shortMessage: "OneKey Stellar provider not found"
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/normalizeNetworkName/normalizeNetworkName.ts
+/**
+* Normalize network name to standard format
+*
+* @param network - Raw network name from wallet
+* @returns Normalized network name (PUBLIC, TESTNET, or FUTURENET)
+*
+* @example
+* ```typescript
+* normalizeNetworkName({ network: 'mainnet' }) // 'PUBLIC'
+* normalizeNetworkName({ network: 'testnet' }) // 'TESTNET'
+* normalizeNetworkName({ network: 'Test SDF Network ; September 2015' }) // 'TESTNET'
+* ```
+* @notInstrumented
+*/
+const normalizeNetworkName = ({ network }) => {
+	const networkUpper = network.toUpperCase();
+	if (networkUpper.includes("FUTURENET") || networkUpper.includes("FUTURE")) return "FUTURENET";
+	if (networkUpper.includes("TESTNET") || networkUpper.includes("TEST SDF")) return "TESTNET";
+	if (networkUpper.includes("PUBLIC") || networkUpper.includes("MAINNET")) return "PUBLIC";
+	return "PUBLIC";
+};
+
+//#endregion
+//#region src/injected/utils/getOneKeyStellarProvider/getOneKeyStellarProvider.ts
+/**
+* Methods the injected OneKey Stellar object must expose to be trusted.
+* `signAuthEntry` is intentionally excluded because it is optional.
+*/
+const REQUIRED_ONEKEY_METHODS = [
+	"disconnect",
+	"getAddress",
+	"getNetwork",
+	"on",
+	"removeListener",
+	"signMessage",
+	"signTransaction"
+];
+/**
+* Gets the OneKey Stellar provider from the window object.
+*
+* The injected `$onekey.stellar` object comes from an untrusted browser global
+* (any extension or script could inject a fake one), so its shape is validated
+* before use: every required method must be a function. Anything that does not
+* conform is rejected rather than trusted.
+*
+* @returns The OneKey Stellar provider, or undefined if it is unavailable or malformed.
+* @notInstrumented
+*/
+const getOneKeyStellarProvider = () => {
+	if (typeof globalThis.window === "undefined") return;
+	const stellar = globalThis.window.$onekey?.stellar;
+	if (!stellar) return;
+	if (!REQUIRED_ONEKEY_METHODS.every((method) => typeof stellar[method] === "function")) return;
+	return stellar;
+};
+
+//#endregion
+//#region src/injected/utils/createOneKeyProvider/createOneKeyProvider.ts
+/**
+* OneKey Wallet provider adapter that implements IStellarProvider
+* using the OneKey Stellar API.
+*
+* @notInstrumented
+*/
+const createOneKeyProvider = () => {
+	const oneKeyProvider = getOneKeyStellarProvider();
+	if (!oneKeyProvider) throw new NotOneKeyProviderError();
+	const eventListeners = /* @__PURE__ */ new Map();
+	const wrappedCallbacks = /* @__PURE__ */ new Map();
+	const oneKeyEventMap = {
+		accountChanged: "accountChanged",
+		networkChanged: "networkChanged"
+	};
+	return {
+		close: () => {
+			eventListeners.forEach((callbacks, event) => {
+				const oneKeyEvent = oneKeyEventMap[event];
+				callbacks.forEach((callback) => {
+					const wrappedCallback = wrappedCallbacks.get(event)?.get(callback);
+					if (wrappedCallback) oneKeyProvider.removeListener(oneKeyEvent, wrappedCallback);
+				});
+			});
+			eventListeners.clear();
+			wrappedCallbacks.clear();
+		},
+		connect: async () => {
+			return (await oneKeyProvider.getAddress())?.address ?? "";
+		},
+		disconnect: async () => {
+			oneKeyProvider.disconnect();
+		},
+		getNetwork: async () => {
+			return normalizeNetworkName({ network: await oneKeyProvider.getNetwork() });
+		},
+		isUnlocked: async () => {
+			try {
+				await oneKeyProvider.getAddress();
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		on: ({ event, callback }) => {
+			if (!eventListeners.has(event)) eventListeners.set(event, /* @__PURE__ */ new Set());
+			const callbacks = eventListeners.get(event);
+			if (callbacks?.has(callback)) return;
+			callbacks?.add(callback);
+			const oneKeyEvent = oneKeyEventMap[event];
+			const wrappedCallback = (...args) => {
+				callback(args[0]);
+			};
+			if (!wrappedCallbacks.has(event)) wrappedCallbacks.set(event, /* @__PURE__ */ new Map());
+			wrappedCallbacks.get(event)?.set(callback, wrappedCallback);
+			oneKeyProvider.on(oneKeyEvent, wrappedCallback);
+		},
+		sign: async ({ transactionXdr, options }) => {
+			return await oneKeyProvider.signTransaction(transactionXdr, {
+				network: options?.network,
+				networkPassphrase: options?.networkPassphrase
+			}) ?? "";
+		},
+		signMessage: async ({ message }) => {
+			const signature = await oneKeyProvider.signMessage(message);
+			return String(signature?.signedMessage ?? "");
+		}
+	};
+};
+
+//#endregion
+//#region src/utils/constants.ts
+/**
+* Stellar network passphrase for mainnet
+*/
+const STELLAR_PUBLIC_NETWORK_PASSPHRASE = "Public Global Stellar Network ; September 2015";
+/**
+* Stellar network passphrase for testnet
+*/
+const STELLAR_TESTNET_NETWORK_PASSPHRASE = "Test SDF Network ; September 2015";
+/**
+* Stellar network passphrase for futurenet
+*/
+const STELLAR_FUTURENET_NETWORK_PASSPHRASE = "Test SDF Future Network ; October 2022";
+/**
+* Network passphrase keyed by Stellar network name. The SDK's network
+* identifier (chain ID) is the SHA-256 hash of these passphrases.
+*/
+const STELLAR_PASSPHRASE_BY_NAME = {
+	FUTURENET: STELLAR_FUTURENET_NETWORK_PASSPHRASE,
+	PUBLIC: STELLAR_PUBLIC_NETWORK_PASSPHRASE,
+	TESTNET: STELLAR_TESTNET_NETWORK_PASSPHRASE
+};
+/**
+* Public Horizon server URL keyed by Stellar network name. Transaction
+* submission must target a write-capable Horizon server (not an arbitrary RPC
+* URL, which returns 405 on POST /transactions).
+*/
+const STELLAR_HORIZON_URL_BY_NAME = {
+	FUTURENET: "https://horizon-futurenet.stellar.org",
+	PUBLIC: "https://horizon.stellar.org",
+	TESTNET: "https://horizon-testnet.stellar.org"
+};
+
+//#endregion
+//#region src/utils/getStellarNetworkId/getStellarNetworkId.ts
+/**
+* Maps a wallet-reported Stellar network (name or passphrase) to its Dynamic
+* network identifier: the hex-encoded SHA-256 hash of the network passphrase
+* (Stellar's canonical Network ID), which is how the backend identifies the
+* network.
+*
+* @param network - Raw network value reported by the wallet.
+* @returns The hex SHA-256 hash of the network passphrase.
+*
+* @example
+* ```typescript
+* // pubnet -> 7ac33997544e3175d266bd022439b22cdb16508c01163f26e5cb2a3e1045a979
+* getStellarNetworkId({ network: 'PUBLIC' });
+* ```
+* @notInstrumented
+*/
+const getStellarNetworkId = ({ network }) => {
+	const passphrase = STELLAR_PASSPHRASE_BY_NAME[normalizeNetworkName({ network })];
+	return hash(getBuffer().from(passphrase)).toString("hex");
+};
+
+//#endregion
+//#region src/utils/getNetworkPassphrase/getNetworkPassphrase.ts
+/**
+* Gets the network passphrase for a given Dynamic Stellar network id (the
+* SHA-256 hash of a network passphrase). Defaults to the public network when
+* the id is unknown.
+*
+* @param networkId - The network id (hex SHA-256 hash of the passphrase).
+* @returns The matching network passphrase.
+* @notInstrumented
+*/
+const getNetworkPassphrase = ({ networkId }) => Object.values(STELLAR_PASSPHRASE_BY_NAME).find((passphrase) => getStellarNetworkId({ network: passphrase }) === networkId) ?? STELLAR_PUBLIC_NETWORK_PASSPHRASE;
+
+//#endregion
+//#region src/isStellarWalletProvider/isStellarWalletProvider.ts
+/**
+* Type guard to check if a wallet provider is a Stellar wallet provider.
+*
+* @param provider - The wallet provider to check.
+* @returns True if the wallet provider is a Stellar wallet provider.
+* @notInstrumented
+*/
+const isStellarWalletProvider = (provider) => {
+	return provider.chain === "STELLAR";
+};
+
+//#endregion
+//#region src/signTransaction/signTransaction.ts
+/**
+* Signs a Stellar transaction
+* @param params.transactionXdr - The transaction XDR to sign
+* @param params.walletAccount - The wallet account to sign the transaction with
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+*
+* @returns An object containing the signed XDR
+* @notInstrumented
+*/
+const signTransaction = async ({ transactionXdr, walletAccount }, client = getDefaultClient()) => {
+	const provider = getWalletProviderFromWalletAccount({ walletAccount }, client);
+	if (!isStellarWalletProvider(provider)) throw new NotStellarProviderError({ providerKey: provider.key });
+	return provider.signTransaction({
+		transactionXdr,
+		walletAccount
+	});
+};
+
+//#endregion
+//#region src/utils/buildPaymentTransaction/buildPaymentTransaction.ts
+const DEFAULT_TIMEOUT_SECONDS = 180;
+/**
+* Builds a Stellar payment transaction sending `amount` of `asset` from the
+* source account to the recipient.
+*
+* @param amount - Amount to send, as a decimal string in the asset's units.
+* @param asset - The asset to send (native or custom).
+* @param networkPassphrase - The network passphrase to sign against.
+* @param recipient - The destination account address.
+* @param sourceAccount - The sender's account loaded from Horizon.
+* @notInstrumented
+*/
+const buildPaymentTransaction = ({ amount, asset, networkPassphrase, recipient, sourceAccount }) => new TransactionBuilder(sourceAccount, {
+	fee: BASE_FEE,
+	networkPassphrase
+}).addOperation(Operation.payment({
+	amount,
+	asset,
+	destination: recipient
+})).setTimeout(DEFAULT_TIMEOUT_SECONDS).build();
+
+//#endregion
+//#region src/utils/checkTrustline/checkTrustline.ts
+/**
+* Returns whether an account can receive the given asset. The native asset
+* (XLM) never needs a trustline; non-native assets require a matching
+* credit balance (trustline) on the account.
+*
+* @param account - The destination account loaded from Horizon.
+* @param asset - The asset being sent.
+* @notInstrumented
+*/
+const checkTrustline = ({ account, asset }) => {
+	if (asset.isNative()) return true;
+	const assetCode = asset.getCode();
+	const assetIssuer = asset.getIssuer();
+	return account.balances.some((balance) => (balance.asset_type === "credit_alphanum4" || balance.asset_type === "credit_alphanum12") && balance.asset_code === assetCode && balance.asset_issuer === assetIssuer);
+};
+
+//#endregion
+//#region src/utils/createPaymentAsset/createPaymentAsset.ts
+/**
+* Creates a Stellar Asset for a payment operation. Returns the native asset
+* (XLM) when no code/issuer is provided, otherwise a custom asset.
+*
+* @param asset - Optional `{ code, issuer }` for a non-native asset.
+* @notInstrumented
+*/
+const createPaymentAsset = (asset) => asset ? new Asset(asset.code, asset.issuer) : Asset.native();
+
+//#endregion
+//#region src/utils/stellarTransferAmount/stellarTransferAmount.ts
+/**
+* Transfers native XLM or a custom Stellar asset from a wallet account.
+*
+* A custom asset is identified by `token.address` in the form `CODE:ISSUER`
+* (or `CODE-ISSUER`). Amounts are decimal strings in the asset's display
+* units. The destination account must exist, and for non-native assets it must
+* already hold a trustline for the asset.
+*
+* @param amount - Amount to send, as a decimal string (e.g. "1.5").
+* @param recipient - Destination Stellar account address.
+* @param token - Optional non-native asset (`address: "CODE:ISSUER"`).
+* @param walletAccount - The Stellar wallet account to send from.
+* @param client - The Dynamic client instance.
+* @returns The submitted transaction hash.
+* @notInstrumented
+*/
+const stellarTransferAmount = async ({ amount, recipient, token, walletAccount }, client) => {
+	if (!isStellarWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account is not a Stellar wallet account");
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, "No active network data found");
+	const networkPassphrase = getNetworkPassphrase({ networkId: networkData.networkId });
+	const horizonUrl = STELLAR_HORIZON_URL_BY_NAME[normalizeNetworkName({ network: networkPassphrase })];
+	const server = new Horizon.Server(horizonUrl);
+	let asset;
+	if (token?.address) {
+		const [code, issuer] = token.address.split(/[:-]/);
+		if (!code || !issuer) throw new InvalidParamError("Invalid token address. Expected \"CODE:ISSUER\" (e.g. \"USDC:GA5Z...\").");
+		asset = createPaymentAsset({
+			code,
+			issuer
+		});
+	} else asset = createPaymentAsset();
+	const sourceAccount = await server.loadAccount(walletAccount.address);
+	let destinationAccount;
+	try {
+		destinationAccount = await server.loadAccount(recipient);
+	} catch {
+		throw new InvalidParamError(`Destination account ${recipient} does not exist or is not funded.`);
+	}
+	if (!asset.isNative() && !checkTrustline({
+		account: destinationAccount,
+		asset
+	})) throw new InvalidParamError(`Destination ${recipient} has no trustline for ${asset.getCode()}:${asset.getIssuer()}.`);
+	const { signedXdr } = await signTransaction({
+		transactionXdr: buildPaymentTransaction({
+			amount,
+			asset,
+			networkPassphrase,
+			recipient,
+			sourceAccount
+		}).toXDR(),
+		walletAccount
+	}, client);
+	const signedTransaction = TransactionBuilder.fromXDR(signedXdr, networkPassphrase);
+	return { transactionHash: (await server.submitTransaction(signedTransaction)).hash };
+};
+
+//#endregion
+//#region src/injected/utils/createWalletProviderFromStellarProvider/createWalletProviderFromStellarProvider.ts
+/**
+* Builds a Stellar wallet provider from an injected Stellar provider adapter.
+*
+* @param dynamicClient - The Dynamic client instance.
+* @param stellarProvider - The injected Stellar provider adapter.
+* @param walletInfo - Display metadata for the wallet (name, icon, key).
+* @notInstrumented
+*/
+const createWalletProviderFromStellarProvider = ({ dynamicClient, stellarProvider, walletInfo }) => {
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain: "STELLAR",
+		displayName: walletInfo.displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		return { addresses: [{ address: await stellarProvider.connect() }] };
+	};
+	const getActiveNetworkId = async () => {
+		return { networkId: getStellarNetworkId({ network: await stellarProvider.getNetwork() }) };
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: [await stellarProvider.connect()] };
+	};
+	const signMessage$2 = async ({ message, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		return { signature: await stellarProvider.signMessage({ message }) };
+	};
+	const signTransaction$3 = async ({ transactionXdr, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const { networkData } = await getActiveNetworkData({ walletAccount }, dynamicClient);
+		assertDefined(networkData, "No active network data found");
+		const networkPassphrase = getNetworkPassphrase({ networkId: networkData.networkId });
+		return { signedXdr: await stellarProvider.sign({
+			options: { networkPassphrase },
+			transactionXdr
+		}) };
+	};
+	const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+		removeEventListeners: ({ setupReturnValue }) => {
+			assertDefined(setupReturnValue, "Setup return value not defined");
+			setupReturnValue.removeNetworkChangeListener();
+			setupReturnValue.removeAccountChangeListener();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged }) => {
+			const onAccountsChanged = (address) => {
+				if (typeof address === "string") handleAccountsChanged({ addresses: [address] });
+			};
+			stellarProvider.on?.({
+				callback: onAccountsChanged,
+				event: "accountChanged"
+			});
+			const removeAccountChangeListener = () => {};
+			const onNetworkChanged = (network) => {
+				if (typeof network === "string") handleNetworkChanged({ networkId: getStellarNetworkId({ network }) });
+			};
+			stellarProvider.on?.({
+				callback: onNetworkChanged,
+				event: "networkChanged"
+			});
+			const removeNetworkChangeListener = () => {};
+			return {
+				removeAccountChangeListener,
+				removeNetworkChangeListener
+			};
+		},
+		supportedEvents: ["accountsChanged", "networkChanged"]
+	});
+	const destroy = async () => {
+		cleanupEventEmitter();
+		stellarProvider.close?.();
+	};
+	const disconnectWalletAccount = async () => {
+		await stellarProvider.disconnect?.();
+	};
+	return {
+		chain: "STELLAR",
+		connect,
+		destroy,
+		disconnectWalletAccount,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(walletInfo.displayName),
+		key,
+		metadata: {
+			displayName: walletInfo.displayName,
+			icon: walletInfo.icon
+		},
+		signMessage: signMessage$2,
+		signTransaction: signTransaction$3,
+		transferAmount: (args) => stellarTransferAmount(args, dynamicClient),
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/addStellarInjectedWalletsExtension/addStellarInjectedWalletsExtension.ts
+const STELLAR_INJECTED_WALLETS_EXTENSION_KEY = "stellarInjectedWallets";
+/**
+* Adds the Stellar Injected Wallets extension to the Dynamic client.
+*
+* This extension enables integration with Stellar wallets, including Freighter, Lobstr, and OneKey.
+*
+* Internal: consumers should call `addStellarExtension`, which supplies the
+* client. The client is required here (no `getDefaultClient()` default) per the
+* internal-function client-param rule.
+*
+* @param client - The Dynamic client instance.
+* @notInstrumented
+*/
+const addStellarInjectedWalletsExtension = (client) => {
+	if (hasExtension({ extensionKey: STELLAR_INJECTED_WALLETS_EXTENSION_KEY }, client)) return;
+	registerExtension({ extensionKey: STELLAR_INJECTED_WALLETS_EXTENSION_KEY }, client);
+	registerStellarNetworkProviderBuilder(client);
+	const walletProviderRegistry = getWalletProviderRegistry(client);
+	isConnected().then((response) => {
+		if (response.isConnected) try {
+			const walletProvider = createWalletProviderFromStellarProvider({
+				dynamicClient: client,
+				stellarProvider: createFreighterProvider(),
+				walletInfo: {
+					displayName: "Freighter",
+					icon: "https://stellar.creit.tech/wallet-icons/freighter.png",
+					key: "freighter"
+				}
+			});
+			walletProviderRegistry.register({
+				priority: WalletProviderPriority.WINDOW_INJECT,
+				walletProvider
+			});
+		} catch (error) {
+			getCore(client).logger.error("Error creating Freighter provider", error);
+		}
+	}).catch((error) => {
+		getCore(client).logger.error("Error checking Freighter connection", error);
+	});
+	isConnected$1().then(() => {
+		try {
+			const walletProvider = createWalletProviderFromStellarProvider({
+				dynamicClient: client,
+				stellarProvider: createLobstrProvider(),
+				walletInfo: {
+					displayName: "Lobstr",
+					icon: "https://stellar.creit.tech/wallet-icons/lobstr.svg",
+					key: "lobstr"
+				}
+			});
+			walletProviderRegistry.register({
+				priority: WalletProviderPriority.WINDOW_INJECT,
+				walletProvider
+			});
+		} catch (error) {
+			getCore(client).logger.error("Error creating Lobstr provider", error);
+		}
+	}).catch((error) => {
+		getCore(client).logger.error("Error checking Lobstr connection", error);
+	});
+	Promise.resolve().then(() => {
+		if (getOneKeyStellarProvider()) try {
+			const walletProvider = createWalletProviderFromStellarProvider({
+				dynamicClient: client,
+				stellarProvider: createOneKeyProvider(),
+				walletInfo: {
+					displayName: "OneKey",
+					icon: "https://uni.onekey-asset.com/static/logo/onekey.png",
+					key: "onekey"
+				}
+			});
+			walletProviderRegistry.register({
+				priority: WalletProviderPriority.WINDOW_INJECT,
+				walletProvider
+			});
+		} catch (error) {
+			getCore(client).logger.error("Error creating OneKey provider", error);
+		}
+	}).catch((error) => {
+		getCore(client).logger.error("Error checking OneKey connection", error);
+	});
+};
+
+//#endregion
+//#region src/addStellarExtension/addStellarExtension.ts
+/**
+* Adds the Stellar extension to the Dynamic client.
+*
+* This is a convenience function that adds support for Stellar wallets,
+* including Freighter, Lobstr, and OneKey.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @notInstrumented
+*/
+const addStellarExtension = (client = getDefaultClient$1()) => {
+	addStellarInjectedWalletsExtension(client);
+};
+
 //#endregion
 //#region src/exports/index.ts
 assertPackageVersion(name, version);
 
 //#endregion
-export { NotStellarProviderError, isStellarWalletAccount };
+export { NotStellarProviderError, addStellarExtension, isStellarWalletAccount, signTransaction };
 //# sourceMappingURL=index.esm.js.map