@dynamic-labs/stellar 4.61.6 → 4.62.0

package/CHANGELOG.md

@@ -1,4 +1,26 @@
 
+## [4.62.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.61.7...v4.62.0) (2026-02-23)
+
+
+### Features
+
+* add stellar waas connector ([#10472](https://github.com/dynamic-labs/dynamic-auth/issues/10472)) ([8349afe](https://github.com/dynamic-labs/dynamic-auth/commit/8349afece59b430ef398585b372d4cd2733c0ce4))
+
+
+### Bug Fixes
+
+* **react-native:** ensure transaction confirmation UI is displayed ([#10488](https://github.com/dynamic-labs/dynamic-auth/issues/10488)) ([dfa2304](https://github.com/dynamic-labs/dynamic-auth/commit/dfa230435a9ce0febc5b66fcca5098cbe979f8d7))
+
+### [4.61.7](https://github.com/dynamic-labs/dynamic-auth/compare/v4.61.6...v4.61.7) (2026-02-20)
+
+
+### Bug Fixes
+
+* coinbase deeplink url ([#10468](https://github.com/dynamic-labs/dynamic-auth/issues/10468)) ([5bd249f](https://github.com/dynamic-labs/dynamic-auth/commit/5bd249ff3788a9718aee802840a73b408675a02b))
+* **react-native:** ensure sign transaction with viem ([#10463](https://github.com/dynamic-labs/dynamic-auth/issues/10463)) ([1048694](https://github.com/dynamic-labs/dynamic-auth/commit/1048694f2a468780ce7398c5ed82a38e6d3e0d76))
+* **react-native:** upgrade react-native-passkey to v3.3.2 ([#10453](https://github.com/dynamic-labs/dynamic-auth/issues/10453)) ([db68ec8](https://github.com/dynamic-labs/dynamic-auth/commit/db68ec819fe8d3e326ed7ed36b1701b0cb3caded))
+* **solana:** token 2022 send balance ([#10470](https://github.com/dynamic-labs/dynamic-auth/issues/10470)) ([2c5ee3e](https://github.com/dynamic-labs/dynamic-auth/commit/2c5ee3e007d1e0feb02b632deb6d23f8f6ba55f7))
+
 ### [4.61.6](https://github.com/dynamic-labs/dynamic-auth/compare/v4.61.5...v4.61.6) (2026-02-19)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.61.6";
+var version = "4.62.0";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.61.6";
+var version = "4.62.0";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/stellar",
-  "version": "4.61.6",
+  "version": "4.62.0",
   "description": "A React SDK for implementing Stellar wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -20,14 +20,16 @@
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.0.864",
     "@stellar/stellar-sdk": "14.4.3",
-    "@dynamic-labs/wallet-connector-core": "4.61.6",
-    "@dynamic-labs/assert-package-version": "4.61.6",
+    "@dynamic-labs/wallet-connector-core": "4.62.0",
+    "@dynamic-labs/assert-package-version": "4.62.0",
     "@lobstrco/signer-extension-api": "2.0.0",
     "@stellar/freighter-api": "6.0.1",
-    "@dynamic-labs/logger": "4.61.6",
-    "@dynamic-labs/types": "4.61.6",
-    "@dynamic-labs/utils": "4.61.6",
-    "@dynamic-labs/wallet-book": "4.61.6"
+    "@dynamic-labs/logger": "4.62.0",
+    "@dynamic-labs/types": "4.62.0",
+    "@dynamic-labs/utils": "4.62.0",
+    "@dynamic-labs/waas": "4.62.0",
+    "@dynamic-labs/wallet-book": "4.62.0",
+    "eventemitter3": "5.0.1"
   },
   "peerDependencies": {}
 }

package/src/connectors/DynamicWaasStellarConnector/DynamicWaasStellarConnector.cjs

@@ -0,0 +1,301 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var stellarSdk = require('@stellar/stellar-sdk');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var utils = require('@dynamic-labs/utils');
+var waas = require('@dynamic-labs/waas');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var logger = require('@dynamic-labs/logger');
+var StellarWalletConnector = require('../StellarWalletConnector/StellarWalletConnector.cjs');
+var StellarUiTransaction = require('../../utils/StellarUiTransaction/StellarUiTransaction.cjs');
+var StellarWallet = require('../../wallet/StellarWallet.cjs');
+
+/**
+ * WaaS (Wallet-as-a-Service) connector for Stellar blockchain.
+ * Extends the base StellarWalletConnector with MPC wallet functionality.
+ */
+class DynamicWaasStellarConnector extends waas.withDynamicWaas(StellarWalletConnector.StellarWalletConnector) {
+    /**
+     * @param props - Constructor properties including walletUiUtils
+     */
+    constructor(props) {
+        super('Dynamic Waas', props);
+        this.ChainWallet = StellarWallet.StellarWallet;
+        this.name = 'Dynamic Waas';
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.logger = new logger.Logger('DynamicWaasStellarConnector');
+        this.walletUiUtils = props.walletUiUtils;
+    }
+    /**
+     * Signs a message with additional context information
+     * @param message - The message to sign (string or object with raw property)
+     * @param context - Additional context for the message signing
+     * @returns The signed message as a string
+     * @throws {Error} Method not implemented for Stellar
+     */
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    signMessageWithContext({ message, context, }) {
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Override setVerifiedCredentials to filter and set Stellar WaaS credentials
+     * Filters for credentials with walletName === 'dynamicwaas' and chain === 'stellar'
+     */
+    setVerifiedCredentials(verifiedCredentials) {
+        this.verifiedCredentials = verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' && vc.chain === 'stellar');
+    }
+    /**
+     * Override setEnvironmentId to ensure it's set on the logger
+     */
+    setEnvironmentId(environmentId) {
+        super.setEnvironmentId(environmentId);
+    }
+    /**
+     * Gets the wallet client for a specific account address and sets it as active
+     * @param accountAddress - The Stellar account address
+     * @returns The WaaS wallet client instance
+     */
+    getWalletClientByAddress(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            this.setActiveAccountAddress(accountAddress);
+            return this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Stellar account address to set as active
+     */
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    /**
+     * Called when the user selects this wallet in the modal.
+     * Sets the active account so getAddress/getNetwork work correctly during network validation.
+     */
+    afterWalletSelectHook(walletAddress) {
+        this.setActiveAccountAddress(walletAddress);
+    }
+    /**
+     * Requires and returns the signed session ID
+     * @returns The signed session ID
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    requireSignedSessionId() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new utils.DynamicError('Signed session ID is required');
+            }
+            return signedSessionId;
+        });
+    }
+    /**
+     * Validates that the expected wallet address matches the active wallet
+     * Updates the active account address if it doesn't match
+     * @param expectedAddress - The expected wallet address to validate
+     * @throws {DynamicError} If signed session ID is not available or account is not found
+     */
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const targetWallet = yield walletClient.getWallet({
+                accountAddress: expectedAddress,
+                authToken: (_a = this.getAuthToken) === null || _a === void 0 ? void 0 : _a.call(this),
+                signedSessionId,
+            });
+            if (!targetWallet) {
+                throw new utils.DynamicError('Account not found');
+            }
+            const isWalletActive = walletConnectorCore.isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    /**
+     * When active account is not set (e.g. primary wallet restored from session),
+     * fall back to the first Stellar verified credential so signing and getAddress work.
+     */
+    ensureActiveAccountFromVerifiedCredentials() {
+        var _a, _b;
+        if (this.activeAccountAddress)
+            return;
+        const address = (_b = (_a = this.verifiedCredentials) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.address;
+        if (typeof address === 'string') {
+            this.setActiveAccountAddress(address);
+        }
+    }
+    /**
+     * Gets the active wallet address
+     * Falls back to verified credential address if no active account is set
+     * @returns The wallet address or empty string if not found
+     */
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.ensureActiveAccountFromVerifiedCredentials();
+            return this.activeAccountAddress || '';
+        });
+    }
+    /**
+     * Connects to the WaaS wallet client
+     */
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Signs a message using the wallet UI utils for user interaction
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     */
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    /**
+     * Internal method to sign a message with MFA token
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    internalSignMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: sdkApiCore.MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({
+                accountAddress: this.activeAccountAddress,
+            });
+            const signedMessage = yield walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                message,
+                mfaToken,
+                password,
+                signedSessionId,
+            });
+            return signedMessage;
+        });
+    }
+    /**
+     * Ends the current session and clears the active account address
+     */
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield _super.endSession.call(this);
+            this.activeAccountAddress = undefined;
+        });
+    }
+    /**
+     * Signs a Stellar transaction XDR.
+     * @param transactionXdr - The XDR-encoded transaction envelope to sign
+     * @returns The signature as a base64 string
+     */
+    signTransaction(transactionXdr) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: sdkApiCore.MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({
+                accountAddress: this.activeAccountAddress,
+            });
+            // Get the transaction hash that needs to be signed
+            const networkPassphrase = yield this.getNetworkPassphrase();
+            const transaction = stellarSdk.TransactionBuilder.fromXDR(transactionXdr, networkPassphrase);
+            const transactionHash = transaction.hash().toString('hex');
+            // Sign the transaction hash using MPC
+            const signature = yield walletClient.signTransaction({
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                mfaToken,
+                password,
+                senderAddress: this.activeAccountAddress,
+                signedSessionId,
+                transaction: transactionHash,
+            });
+            // The signature from WaaS is base64 encoded
+            // addSignature expects both public key and signature as strings
+            transaction.addSignature(this.activeAccountAddress, signature);
+            // Return the signed transaction XDR
+            return transaction.toXDR();
+        });
+    }
+    /**
+     * Creates a UI transaction for the send balance flow
+     * @param from - The sender's address (Stellar public key)
+     * @returns A new StellarUiTransaction instance
+     */
+    createUiTransaction(from) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const horizonServer = yield this.getHorizonServer();
+            const networkPassphrase = yield this.getNetworkPassphrase();
+            if (!horizonServer) {
+                throw new utils.DynamicError('No Horizon server available');
+            }
+            return new StellarUiTransaction.StellarUiTransaction({
+                from,
+                horizonServer,
+                networkPassphrase,
+                onSubmit: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    if (!transaction) {
+                        throw new utils.DynamicError('Transaction must be provided');
+                    }
+                    const signedXdr = yield this.signTransaction(transaction.toXDR());
+                    const signedTransaction = stellarSdk.TransactionBuilder.fromXDR(signedXdr, networkPassphrase);
+                    const result = yield horizonServer.submitTransaction(signedTransaction);
+                    return result.hash;
+                }),
+            });
+        });
+    }
+    /**
+     * Returns the Stellar provider.
+     * For WaaS, we don't have a traditional browser provider.
+     */
+    getProvider() {
+        return undefined;
+    }
+}
+
+exports.DynamicWaasStellarConnector = DynamicWaasStellarConnector;

package/src/connectors/DynamicWaasStellarConnector/DynamicWaasStellarConnector.d.ts

@@ -0,0 +1,267 @@
+import { JwtVerifiedCredential, MFAAction, SignMessageContext } from '@dynamic-labs/sdk-api-core';
+import { IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
+import { IDynamicWaasConnector, InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { Logger } from '@dynamic-labs/logger';
+import { StellarWalletConnector } from '../StellarWalletConnector/StellarWalletConnector';
+import type { StellarWalletConnectorProps } from '../../types';
+import { StellarWallet } from '../../wallet/StellarWallet';
+export type DynamicWaasStellarConnectorProps = StellarWalletConnectorProps & {
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+};
+declare const DynamicWaasStellarConnector_base: (abstract new (...args: any[]) => {
+    [x: string]: any;
+    name: string;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    getSignedSessionId?: (() => Promise<string>) | undefined;
+    getMfaToken?: ((props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>) | undefined;
+    getWalletPassword?: import("@dynamic-labs/wallet-connector-core").GetWalletPasswordFn | undefined;
+    getAuthToken?: (() => string) | undefined;
+    environmentId?: string | undefined;
+    baseApiUrl?: string | undefined;
+    relayUrl?: string | undefined;
+    baseClientKeysharesRelayApiUrl?: string | undefined;
+    dynamicWaasClient: import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient | undefined;
+    chainName: string;
+    authMode: "cookie" | "header";
+    logger: Logger;
+    __exportHandler: import("@dynamic-labs/waas").WaasExportHandler;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    setGetAuthTokenFunction(getAuthToken: () => string): void;
+    setWaasAuthMode(authMode: "cookie" | "header"): void;
+    setGetMfaTokenFunction(getMfaToken: (props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>): void;
+    setGetWalletPasswordFunction(getWalletPassword: import("@dynamic-labs/wallet-connector-core").GetWalletPasswordFn): void;
+    getPasswordIfNeeded({ accountAddress, }: {
+        accountAddress: string;
+    }): Promise<string | undefined>;
+    setEnvironmentId(environmentId: string): void;
+    setBaseApiUrl(baseApiUrl: string): void;
+    setBaseClientKeysharesRelayApiUrl(baseClientKeysharesRelayApiUrl?: string | undefined): void;
+    setRelayUrl(relayUrl: string): void;
+    setGetSignedSessionIdFunction(getSignedSessionId: () => Promise<string>): void;
+    delegateKeyShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    createDynamicWaasClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    getWaasWalletClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    createWalletAccount({ thresholdSignatureScheme, password, bitcoinConfig, }?: {
+        thresholdSignatureScheme?: string | undefined;
+        password?: string | undefined;
+        bitcoinConfig?: import("@dynamic-labs-wallet/core").BitcoinConfig | undefined;
+    } | undefined): Promise<{
+        chainName: string;
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: string | Uint8Array | undefined;
+    }>;
+    importPrivateKey({ privateKey, thresholdSignatureScheme, publicAddressCheck, addressType, legacyWalletId, password, }: {
+        privateKey: string;
+        thresholdSignatureScheme?: string | undefined;
+        publicAddressCheck?: string | undefined;
+        addressType?: string | undefined;
+        legacyWalletId?: string | undefined;
+        password?: string | undefined;
+    }): Promise<void>;
+    exportPrivateKey({ accountAddress, displayContainer, password, }?: {
+        accountAddress?: string | undefined;
+        displayContainer?: HTMLIFrameElement | undefined;
+        password?: string | undefined;
+    } | undefined): Promise<void>;
+    getExportHandler(): {
+        clear: () => void;
+    };
+    exportClientKeyshares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    backupKeySharesToGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    exportClientKeysharesFromGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    backupKeySharesToICloud({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    displayICloudSignIn({ displayContainer, }: {
+        displayContainer: HTMLElement;
+    }): Promise<void>;
+    hideICloudSignIn(): Promise<void>;
+    isICloudAuthenticated(): Promise<boolean>;
+    refreshWalletAccountShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    reshareWalletAccountShares({ accountAddress, thresholdSignatureScheme, password, }: {
+        accountAddress: string;
+        thresholdSignatureScheme: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    revokeDelegation({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    updatePassword({ accountAddress, existingPassword, newPassword, }: {
+        accountAddress: string;
+        existingPassword?: string | undefined;
+        newPassword: string;
+    }): Promise<void>;
+    signRawMessage({ accountAddress, message, password, }: {
+        accountAddress: string;
+        message: string;
+        password?: string | undefined;
+    }): Promise<string>;
+    unlockWallet({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<import("@dynamic-labs-wallet/core").GetWalletResponse>;
+    getWalletRecoveryState({ accountAddress, }: {
+        accountAddress: string;
+    }): Promise<import("@dynamic-labs-wallet/core").WalletRecoveryState>;
+    endSession(): Promise<void>;
+    getActiveAccountAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    generateTraceId(): string;
+    instrument(message: string, context: import("@dynamic-labs/logger").InstrumentOptions & import("dist/packages/waas/utils/instrumentation").InstrumentContext & Record<string, any>): void;
+    instrumentAsync<T_1>({ operation, resource, fn, context, }: {
+        operation: string;
+        resource: string;
+        fn: (timing: import("dist/packages/waas/utils/instrumentation").InstrumentationTimer) => Promise<T_1>;
+        context?: Record<string, any> | undefined;
+    }): Promise<T_1>;
+}) & typeof StellarWalletConnector;
+/**
+ * WaaS (Wallet-as-a-Service) connector for Stellar blockchain.
+ * Extends the base StellarWalletConnector with MPC wallet functionality.
+ */
+export declare class DynamicWaasStellarConnector extends DynamicWaasStellarConnector_base implements IDynamicWaasConnector {
+    ChainWallet: typeof StellarWallet;
+    name: string;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    logger: Logger;
+    activeAccountAddress: string | undefined;
+    verifiedCredentials: JwtVerifiedCredential[] | undefined;
+    protected walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+    /**
+     * @param props - Constructor properties including walletUiUtils
+     */
+    constructor(props: DynamicWaasStellarConnectorProps);
+    /**
+     * Signs a message with additional context information
+     * @param message - The message to sign (string or object with raw property)
+     * @param context - Additional context for the message signing
+     * @returns The signed message as a string
+     * @throws {Error} Method not implemented for Stellar
+     */
+    signMessageWithContext({ message, context, }: {
+        message: string | {
+            raw: string;
+        };
+        context: SignMessageContext;
+    }): Promise<string>;
+    /**
+     * Override setVerifiedCredentials to filter and set Stellar WaaS credentials
+     * Filters for credentials with walletName === 'dynamicwaas' and chain === 'stellar'
+     */
+    setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    /**
+     * Override setEnvironmentId to ensure it's set on the logger
+     */
+    setEnvironmentId(environmentId: string): void;
+    /**
+     * Gets the wallet client for a specific account address and sets it as active
+     * @param accountAddress - The Stellar account address
+     * @returns The WaaS wallet client instance
+     */
+    getWalletClientByAddress({ accountAddress, }: {
+        accountAddress: string;
+    }): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress(): Promise<string | undefined>;
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Stellar account address to set as active
+     */
+    private setActiveAccountAddress;
+    /**
+     * Called when the user selects this wallet in the modal.
+     * Sets the active account so getAddress/getNetwork work correctly during network validation.
+     */
+    afterWalletSelectHook(walletAddress: string): void;
+    /**
+     * Requires and returns the signed session ID
+     * @returns The signed session ID
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    private requireSignedSessionId;
+    /**
+     * Validates that the expected wallet address matches the active wallet
+     * Updates the active account address if it doesn't match
+     * @param expectedAddress - The expected wallet address to validate
+     * @throws {DynamicError} If signed session ID is not available or account is not found
+     */
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    /**
+     * When active account is not set (e.g. primary wallet restored from session),
+     * fall back to the first Stellar verified credential so signing and getAddress work.
+     */
+    private ensureActiveAccountFromVerifiedCredentials;
+    /**
+     * Gets the active wallet address
+     * Falls back to verified credential address if no active account is set
+     * @returns The wallet address or empty string if not found
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Connects to the WaaS wallet client
+     */
+    connect(): Promise<void>;
+    /**
+     * Signs a message using the wallet UI utils for user interaction
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Internal method to sign a message with MFA token
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    internalSignMessage(message: string): Promise<string>;
+    /**
+     * Ends the current session and clears the active account address
+     */
+    endSession(): Promise<void>;
+    /**
+     * Signs a Stellar transaction XDR.
+     * @param transactionXdr - The XDR-encoded transaction envelope to sign
+     * @returns The signature as a base64 string
+     */
+    signTransaction(transactionXdr: string): Promise<string>;
+    /**
+     * Creates a UI transaction for the send balance flow
+     * @param from - The sender's address (Stellar public key)
+     * @returns A new StellarUiTransaction instance
+     */
+    createUiTransaction(from: string): Promise<IUITransaction>;
+    /**
+     * Returns the Stellar provider.
+     * For WaaS, we don't have a traditional browser provider.
+     */
+    getProvider(): undefined;
+}
+export {};

package/src/connectors/DynamicWaasStellarConnector/DynamicWaasStellarConnector.js

@@ -0,0 +1,297 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { TransactionBuilder } from '@stellar/stellar-sdk';
+import { MFAAction } from '@dynamic-labs/sdk-api-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { withDynamicWaas } from '@dynamic-labs/waas';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { Logger } from '@dynamic-labs/logger';
+import { StellarWalletConnector } from '../StellarWalletConnector/StellarWalletConnector.js';
+import { StellarUiTransaction } from '../../utils/StellarUiTransaction/StellarUiTransaction.js';
+import { StellarWallet } from '../../wallet/StellarWallet.js';
+
+/**
+ * WaaS (Wallet-as-a-Service) connector for Stellar blockchain.
+ * Extends the base StellarWalletConnector with MPC wallet functionality.
+ */
+class DynamicWaasStellarConnector extends withDynamicWaas(StellarWalletConnector) {
+    /**
+     * @param props - Constructor properties including walletUiUtils
+     */
+    constructor(props) {
+        super('Dynamic Waas', props);
+        this.ChainWallet = StellarWallet;
+        this.name = 'Dynamic Waas';
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.logger = new Logger('DynamicWaasStellarConnector');
+        this.walletUiUtils = props.walletUiUtils;
+    }
+    /**
+     * Signs a message with additional context information
+     * @param message - The message to sign (string or object with raw property)
+     * @param context - Additional context for the message signing
+     * @returns The signed message as a string
+     * @throws {Error} Method not implemented for Stellar
+     */
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    signMessageWithContext({ message, context, }) {
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Override setVerifiedCredentials to filter and set Stellar WaaS credentials
+     * Filters for credentials with walletName === 'dynamicwaas' and chain === 'stellar'
+     */
+    setVerifiedCredentials(verifiedCredentials) {
+        this.verifiedCredentials = verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' && vc.chain === 'stellar');
+    }
+    /**
+     * Override setEnvironmentId to ensure it's set on the logger
+     */
+    setEnvironmentId(environmentId) {
+        super.setEnvironmentId(environmentId);
+    }
+    /**
+     * Gets the wallet client for a specific account address and sets it as active
+     * @param accountAddress - The Stellar account address
+     * @returns The WaaS wallet client instance
+     */
+    getWalletClientByAddress(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            this.setActiveAccountAddress(accountAddress);
+            return this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Stellar account address to set as active
+     */
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    /**
+     * Called when the user selects this wallet in the modal.
+     * Sets the active account so getAddress/getNetwork work correctly during network validation.
+     */
+    afterWalletSelectHook(walletAddress) {
+        this.setActiveAccountAddress(walletAddress);
+    }
+    /**
+     * Requires and returns the signed session ID
+     * @returns The signed session ID
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    requireSignedSessionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            return signedSessionId;
+        });
+    }
+    /**
+     * Validates that the expected wallet address matches the active wallet
+     * Updates the active account address if it doesn't match
+     * @param expectedAddress - The expected wallet address to validate
+     * @throws {DynamicError} If signed session ID is not available or account is not found
+     */
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const targetWallet = yield walletClient.getWallet({
+                accountAddress: expectedAddress,
+                authToken: (_a = this.getAuthToken) === null || _a === void 0 ? void 0 : _a.call(this),
+                signedSessionId,
+            });
+            if (!targetWallet) {
+                throw new DynamicError('Account not found');
+            }
+            const isWalletActive = isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    /**
+     * When active account is not set (e.g. primary wallet restored from session),
+     * fall back to the first Stellar verified credential so signing and getAddress work.
+     */
+    ensureActiveAccountFromVerifiedCredentials() {
+        var _a, _b;
+        if (this.activeAccountAddress)
+            return;
+        const address = (_b = (_a = this.verifiedCredentials) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.address;
+        if (typeof address === 'string') {
+            this.setActiveAccountAddress(address);
+        }
+    }
+    /**
+     * Gets the active wallet address
+     * Falls back to verified credential address if no active account is set
+     * @returns The wallet address or empty string if not found
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureActiveAccountFromVerifiedCredentials();
+            return this.activeAccountAddress || '';
+        });
+    }
+    /**
+     * Connects to the WaaS wallet client
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Signs a message using the wallet UI utils for user interaction
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     */
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    /**
+     * Internal method to sign a message with MFA token
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    internalSignMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({
+                accountAddress: this.activeAccountAddress,
+            });
+            const signedMessage = yield walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                message,
+                mfaToken,
+                password,
+                signedSessionId,
+            });
+            return signedMessage;
+        });
+    }
+    /**
+     * Ends the current session and clears the active account address
+     */
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.endSession.call(this);
+            this.activeAccountAddress = undefined;
+        });
+    }
+    /**
+     * Signs a Stellar transaction XDR.
+     * @param transactionXdr - The XDR-encoded transaction envelope to sign
+     * @returns The signature as a base64 string
+     */
+    signTransaction(transactionXdr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({
+                accountAddress: this.activeAccountAddress,
+            });
+            // Get the transaction hash that needs to be signed
+            const networkPassphrase = yield this.getNetworkPassphrase();
+            const transaction = TransactionBuilder.fromXDR(transactionXdr, networkPassphrase);
+            const transactionHash = transaction.hash().toString('hex');
+            // Sign the transaction hash using MPC
+            const signature = yield walletClient.signTransaction({
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                mfaToken,
+                password,
+                senderAddress: this.activeAccountAddress,
+                signedSessionId,
+                transaction: transactionHash,
+            });
+            // The signature from WaaS is base64 encoded
+            // addSignature expects both public key and signature as strings
+            transaction.addSignature(this.activeAccountAddress, signature);
+            // Return the signed transaction XDR
+            return transaction.toXDR();
+        });
+    }
+    /**
+     * Creates a UI transaction for the send balance flow
+     * @param from - The sender's address (Stellar public key)
+     * @returns A new StellarUiTransaction instance
+     */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const horizonServer = yield this.getHorizonServer();
+            const networkPassphrase = yield this.getNetworkPassphrase();
+            if (!horizonServer) {
+                throw new DynamicError('No Horizon server available');
+            }
+            return new StellarUiTransaction({
+                from,
+                horizonServer,
+                networkPassphrase,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    if (!transaction) {
+                        throw new DynamicError('Transaction must be provided');
+                    }
+                    const signedXdr = yield this.signTransaction(transaction.toXDR());
+                    const signedTransaction = TransactionBuilder.fromXDR(signedXdr, networkPassphrase);
+                    const result = yield horizonServer.submitTransaction(signedTransaction);
+                    return result.hash;
+                }),
+            });
+        });
+    }
+    /**
+     * Returns the Stellar provider.
+     * For WaaS, we don't have a traditional browser provider.
+     */
+    getProvider() {
+        return undefined;
+    }
+}
+
+export { DynamicWaasStellarConnector };

package/src/connectors/DynamicWaasStellarConnector/index.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicWaasStellarConnector = require('./DynamicWaasStellarConnector.cjs');
+
+const DynamicWaasStellarConnectors = () => [
+    DynamicWaasStellarConnector.DynamicWaasStellarConnector,
+];
+
+exports.DynamicWaasStellarConnector = DynamicWaasStellarConnector.DynamicWaasStellarConnector;
+exports.DynamicWaasStellarConnectors = DynamicWaasStellarConnectors;

package/src/connectors/DynamicWaasStellarConnector/index.d.ts

@@ -0,0 +1,3 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export * from './DynamicWaasStellarConnector';
+export declare const DynamicWaasStellarConnectors: () => WalletConnectorConstructor[];

package/src/connectors/DynamicWaasStellarConnector/index.js

@@ -0,0 +1,9 @@
+'use client'
+import { DynamicWaasStellarConnector } from './DynamicWaasStellarConnector.js';
+export { DynamicWaasStellarConnector } from './DynamicWaasStellarConnector.js';
+
+const DynamicWaasStellarConnectors = () => [
+    DynamicWaasStellarConnector,
+];
+
+export { DynamicWaasStellarConnectors };

package/src/connectors/LobstrWalletConnector/LobstrWalletConnector.js

@@ -1,6 +1,6 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
-import { getPublicKey, isConnected, signTransaction, signMessage } from '@lobstrco/signer-extension-api';
+import { isConnected, getPublicKey, signTransaction, signMessage } from '@lobstrco/signer-extension-api';
 import { StellarWalletConnector } from '../StellarWalletConnector/StellarWalletConnector.js';
 import { StellarWallet } from '../../wallet/StellarWallet.js';
 import '@stellar/stellar-sdk';

package/src/connectors/StellarWalletConnector/StellarWalletConnector.cjs

@@ -46,17 +46,35 @@ class StellarWalletConnector extends walletConnectorCore.WalletConnectorBase {
     getEnabledNetworks() {
         return this.stellarNetworks;
     }
+    supportsNetworkSwitching() {
+        return this.stellarNetworks.length > 1;
+    }
     getSelectedNetwork() {
         var _a;
         return (_a = this.stellarNetworks) === null || _a === void 0 ? void 0 : _a[0];
     }
+    switchNetwork(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (networkChainId === undefined)
+                return;
+            const idStr = String(networkChainId);
+            const network = this.stellarNetworks.find((n) => { var _a, _b; return ((_a = n.chainId) === null || _a === void 0 ? void 0 : _a.toString()) === idStr || ((_b = n.networkId) === null || _b === void 0 ? void 0 : _b.toString()) === idStr; });
+            if (network) {
+                this.selectedNetwork = network;
+                this.emit('chainChange', { chain: String(network.chainId) });
+            }
+        });
+    }
     getNetwork() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddress();
-            if (!address) {
+            if (!this.stellarNetworks.length) {
                 return undefined;
             }
-            if (!this.stellarNetworks.length) {
+            if (this.selectedNetwork) {
+                return this.selectedNetwork.chainId.toString();
+            }
+            const address = yield this.getAddress();
+            if (!address) {
                 return undefined;
             }
             const network = yield getNetworkFromAddress.getNetworkFromAddress(address, this.stellarNetworks[0]);

package/src/connectors/StellarWalletConnector/StellarWalletConnector.d.ts

@@ -38,7 +38,12 @@ export declare abstract class StellarWalletConnector extends WalletConnectorBase
      */
     abstract getProvider(): IStellarProvider | undefined;
     getEnabledNetworks(): GenericNetwork[];
+    supportsNetworkSwitching(): boolean;
     getSelectedNetwork(): GenericNetwork | undefined;
+    switchNetwork({ networkChainId, }: {
+        networkChainId?: number | string;
+        networkName?: string;
+    }): Promise<void>;
     getNetwork(): Promise<string | undefined>;
     /**
      * Checks if the provider is already connected.

package/src/connectors/StellarWalletConnector/StellarWalletConnector.js

@@ -42,17 +42,35 @@ class StellarWalletConnector extends WalletConnectorBase {
     getEnabledNetworks() {
         return this.stellarNetworks;
     }
+    supportsNetworkSwitching() {
+        return this.stellarNetworks.length > 1;
+    }
     getSelectedNetwork() {
         var _a;
         return (_a = this.stellarNetworks) === null || _a === void 0 ? void 0 : _a[0];
     }
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (networkChainId === undefined)
+                return;
+            const idStr = String(networkChainId);
+            const network = this.stellarNetworks.find((n) => { var _a, _b; return ((_a = n.chainId) === null || _a === void 0 ? void 0 : _a.toString()) === idStr || ((_b = n.networkId) === null || _b === void 0 ? void 0 : _b.toString()) === idStr; });
+            if (network) {
+                this.selectedNetwork = network;
+                this.emit('chainChange', { chain: String(network.chainId) });
+            }
+        });
+    }
     getNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddress();
-            if (!address) {
+            if (!this.stellarNetworks.length) {
                 return undefined;
             }
-            if (!this.stellarNetworks.length) {
+            if (this.selectedNetwork) {
+                return this.selectedNetwork.chainId.toString();
+            }
+            const address = yield this.getAddress();
+            if (!address) {
                 return undefined;
             }
             const network = yield getNetworkFromAddress(address, this.stellarNetworks[0]);

package/src/index.cjs

@@ -14,6 +14,8 @@ require('@stellar/stellar-sdk');
 var getNetworkFromAddress = require('./utils/getNetworkFromAddress.cjs');
 require('../_virtual/_tslib.cjs');
 require('@dynamic-labs/utils');
+var index = require('./connectors/DynamicWaasStellarConnector/index.cjs');
+var DynamicWaasStellarConnector = require('./connectors/DynamicWaasStellarConnector/DynamicWaasStellarConnector.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/stellar', _package.version);
 // Wallet connector factory (to be implemented by specific wallet connectors)
@@ -28,4 +30,6 @@ exports.isStellarWallet = isStellarWallet.isStellarWallet;
 exports.StellarWalletConnector = StellarWalletConnector.StellarWalletConnector;
 exports.StellarLocalStorageCache = StellarLocalStorageCache.StellarLocalStorageCache;
 exports.getNetworkFromAddress = getNetworkFromAddress.getNetworkFromAddress;
+exports.DynamicWaasStellarConnectors = index.DynamicWaasStellarConnectors;
+exports.DynamicWaasStellarConnector = DynamicWaasStellarConnector.DynamicWaasStellarConnector;
 exports.StellarWalletConnectors = StellarWalletConnectors;

package/src/index.d.ts

@@ -4,3 +4,4 @@ export { StellarLocalStorageCache, type IStellarSessionCache, type StellarConnec
 export type { IStellarProvider, StellarConnectionResult, StellarEventCallback, StellarMethodName, StellarNetworkName, StellarProviderEvent, StellarSendBalanceProps, StellarSignTransactionOptions, StellarWalletConnectorProps, } from './types';
 export { getNetworkFromAddress } from './utils';
 export declare const StellarWalletConnectors: (_props?: unknown) => import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor[];
+export { DynamicWaasStellarConnector, DynamicWaasStellarConnectors, } from './connectors/DynamicWaasStellarConnector';

package/src/index.js

@@ -10,6 +10,8 @@ import '@stellar/stellar-sdk';
 export { getNetworkFromAddress } from './utils/getNetworkFromAddress.js';
 import '../_virtual/_tslib.js';
 import '@dynamic-labs/utils';
+export { DynamicWaasStellarConnectors } from './connectors/DynamicWaasStellarConnector/index.js';
+export { DynamicWaasStellarConnector } from './connectors/DynamicWaasStellarConnector/DynamicWaasStellarConnector.js';
 
 assertPackageVersion('@dynamic-labs/stellar', version);
 // Wallet connector factory (to be implemented by specific wallet connectors)

package/src/utils/getNetworkFromAddress.cjs

@@ -47,18 +47,16 @@ const accountExistsOnNetwork = (address, server) => _tslib.__awaiter(void 0, voi
 const getNetworkFromAddress = (address, defaultNetwork) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
     const mainnetServer = new stellarSdk.Horizon.Server(HORIZON_MAINNET_URL);
     const testnetServer = new stellarSdk.Horizon.Server(HORIZON_TESTNET_URL);
-    // Check testnet
-    const existsOnTestnet = yield accountExistsOnNetwork(address, testnetServer);
-    if (existsOnTestnet) {
-        return getNetworkIdFromPassphrase(stellarSdk.Networks.TESTNET);
-    }
-    // Check mainnet first since it's the most common
+    // Check mainnet first since it's the most common (avoids unnecessary testnet 404s)
     const existsOnMainnet = yield accountExistsOnNetwork(address, mainnetServer);
     if (existsOnMainnet) {
         return getNetworkIdFromPassphrase(stellarSdk.Networks.PUBLIC);
     }
+    const existsOnTestnet = yield accountExistsOnNetwork(address, testnetServer);
+    if (existsOnTestnet) {
+        return getNetworkIdFromPassphrase(stellarSdk.Networks.TESTNET);
+    }
     // Account doesn't exist on either network (unfunded account)
-    // Default to mainnet
     return defaultNetwork.chainId.toString();
 });
 

package/src/utils/getNetworkFromAddress.js

@@ -43,18 +43,16 @@ const accountExistsOnNetwork = (address, server) => __awaiter(void 0, void 0, vo
 const getNetworkFromAddress = (address, defaultNetwork) => __awaiter(void 0, void 0, void 0, function* () {
     const mainnetServer = new Horizon.Server(HORIZON_MAINNET_URL);
     const testnetServer = new Horizon.Server(HORIZON_TESTNET_URL);
-    // Check testnet
-    const existsOnTestnet = yield accountExistsOnNetwork(address, testnetServer);
-    if (existsOnTestnet) {
-        return getNetworkIdFromPassphrase(Networks.TESTNET);
-    }
-    // Check mainnet first since it's the most common
+    // Check mainnet first since it's the most common (avoids unnecessary testnet 404s)
     const existsOnMainnet = yield accountExistsOnNetwork(address, mainnetServer);
     if (existsOnMainnet) {
         return getNetworkIdFromPassphrase(Networks.PUBLIC);
     }
+    const existsOnTestnet = yield accountExistsOnNetwork(address, testnetServer);
+    if (existsOnTestnet) {
+        return getNetworkIdFromPassphrase(Networks.TESTNET);
+    }
     // Account doesn't exist on either network (unfunded account)
-    // Default to mainnet
     return defaultNetwork.chainId.toString();
 });