@dynamic-labs/tempo 0.0.0 → 4.72.0

package/src/connectors/DynamicWaasTempoConnector/DynamicWaasTempoConnector.js

@@ -0,0 +1,548 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { http, serializeTransaction, createPublicClient, encodeFunctionData, erc20Abi } from 'viem';
+import { toAccount } from 'viem/accounts';
+import { createWalletClientWithUiConfirmation, getOrMapViemChain, ViemUiTransaction } from '@dynamic-labs/ethereum-core';
+import { Logger } from '@dynamic-labs/logger';
+import { MFAAction } from '@dynamic-labs/sdk-api-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { withDynamicWaas, WaasExportHandler } from '@dynamic-labs/waas';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { TempoWalletConnector } from '../TempoWalletConnector/TempoWalletConnector.js';
+
+const logger = new Logger('DynamicWaasTempoConnector');
+// Error message constants
+const ERROR_SIGNED_SESSION_ID_REQUIRED = 'Signed session ID is required';
+const ERROR_TEMPO_NETWORK_NOT_FOUND = 'Tempo network not found';
+class DynamicWaasTempoConnector extends withDynamicWaas(TempoWalletConnector) {
+    constructor(props) {
+        super(props);
+        this.name = 'Dynamic Waas';
+        this.logger = logger;
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this._selectedChainId = this.getLastUsedChainId();
+        this.__exportHandler = new WaasExportHandler();
+    }
+    getLastUsedChainId() {
+        var _a;
+        logger.logVerboseTroubleshootingMessage('[DynamicWaasTempoConnector] getLastUsedChainId', {
+            evmNetworks: this.evmNetworks,
+            lastUsedChainId: this.lastUsedChainId,
+        });
+        if (this.lastUsedChainId) {
+            return this.lastUsedChainId;
+        }
+        if (!((_a = this.evmNetworks) === null || _a === void 0 ? void 0 : _a.length)) {
+            return undefined;
+        }
+        return this.evmNetworks[0].chainId;
+    }
+    set verifiedCredentials(verifiedCredentials) {
+        this._verifiedCredentials = verifiedCredentials;
+    }
+    get verifiedCredentials() {
+        return this._verifiedCredentials;
+    }
+    set verifiedCredential(verifiedCredential) {
+        this._verifiedCredential = verifiedCredential;
+    }
+    get verifiedCredential() {
+        return this._verifiedCredential;
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        // Filter for Tempo WaaS credentials
+        const tempoWaasVerifiedCredentials = verifiedCredentials === null || verifiedCredentials === void 0 ? void 0 : verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' && vc.chain === 'tempo');
+        const [tempoWaasVerifiedCredential] = tempoWaasVerifiedCredentials;
+        const didTempoWaasVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredentials) !==
+            JSON.stringify(tempoWaasVerifiedCredentials);
+        if (!didTempoWaasVerifiedCredentialsChanged) {
+            return;
+        }
+        this.verifiedCredential = tempoWaasVerifiedCredential;
+        this.verifiedCredentials = tempoWaasVerifiedCredentials;
+    }
+    set lastUsedChainId(chainId) {
+        if (chainId === undefined) {
+            localStorage.removeItem(DynamicWaasTempoConnector.lastUsedChainIdStorageKey);
+        }
+        else {
+            localStorage.setItem(DynamicWaasTempoConnector.lastUsedChainIdStorageKey, chainId.toString());
+        }
+        this._selectedChainId = chainId;
+    }
+    get lastUsedChainId() {
+        var _a;
+        const lastUsedChainIdLS = localStorage.getItem(DynamicWaasTempoConnector.lastUsedChainIdStorageKey);
+        if (!lastUsedChainIdLS)
+            return undefined;
+        try {
+            const chainId = parseInt(lastUsedChainIdLS);
+            if (isNaN(chainId)) {
+                return undefined;
+            }
+            const isChainCurrentlyEnabled = this.evmNetworks.some((network) => network.chainId === chainId);
+            if (!isChainCurrentlyEnabled) {
+                if (!((_a = this.evmNetworks) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return undefined;
+                }
+                const lastUsedChainId = this.evmNetworks[0].chainId;
+                this.lastUsedChainId = lastUsedChainId;
+                return lastUsedChainId;
+            }
+            return chainId;
+        }
+        catch (err) {
+            logger.error(err);
+            return undefined;
+        }
+    }
+    get currentChainId() {
+        var _a, _b, _c;
+        return (_a = this._selectedChainId) !== null && _a !== void 0 ? _a : (_c = (_b = this.evmNetworks) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.chainId;
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.currentChainId;
+        });
+    }
+    getEvmNetworkByChainId(chainId) {
+        return this.evmNetworks.find((network) => network.chainId === chainId);
+    }
+    currentEvmNetwork() {
+        const chainId = this.currentChainId;
+        if (!chainId) {
+            return undefined;
+        }
+        return this.getEvmNetworkByChainId(chainId);
+    }
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (!networkChainId) {
+                return;
+            }
+            let networkChainIdInt = networkChainId;
+            if (typeof networkChainId === 'string') {
+                networkChainIdInt = parseInt(networkChainId);
+            }
+            this.lastUsedChainId = networkChainIdInt;
+            this._selectedChainId = networkChainIdInt;
+            this.emit('chainChange', {
+                chain: networkChainIdInt.toString(),
+            });
+        });
+    }
+    getRpcUrl() {
+        var _a;
+        const evmNetwork = this.currentEvmNetwork();
+        if (!evmNetwork) {
+            throw new Error(ERROR_TEMPO_NETWORK_NOT_FOUND);
+        }
+        return ((_a = evmNetwork === null || evmNetwork === void 0 ? void 0 : evmNetwork.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) || (evmNetwork === null || evmNetwork === void 0 ? void 0 : evmNetwork.rpcUrls[0]);
+    }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const walletClient = yield this.getWaasWalletClient();
+            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, ((_b = this.getActiveAccount()) === null || _b === void 0 ? void 0 : _b.address) || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.setActiveAccount(targetWallet.accountAddress);
+            }
+        });
+    }
+    getActiveAccountAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.getActiveAccount()) === null || _a === void 0 ? void 0 : _a.address;
+        });
+    }
+    getViemAccountCustomSource(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            var _b;
+            const client = yield this.getWaasWalletClient();
+            const signedSessionId = yield ((_b = this.getSignedSessionId) === null || _b === void 0 ? void 0 : _b.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError(ERROR_SIGNED_SESSION_ID_REQUIRED);
+            }
+            return {
+                address: accountAddress,
+                signMessage: (_c) => __awaiter(this, [_c], void 0, function* ({ message, }) {
+                    var _d;
+                    const traceId = this.generateTraceId();
+                    const startTime = Date.now();
+                    this.instrument('[signMessage] start', {
+                        accountAddress,
+                        chainName: 'TEMPO',
+                        key: 'signMessage-start',
+                        startTime,
+                        time: 0,
+                        traceId,
+                    });
+                    const mfaToken = yield ((_d = this.getMfaToken) === null || _d === void 0 ? void 0 : _d.call(this, {
+                        mfaAction: MFAAction.WalletWaasSign,
+                    }));
+                    const password = yield this.getPasswordIfNeeded({
+                        accountAddress,
+                    });
+                    const signature = yield this.instrumentAsync({
+                        context: { chainName: 'TEMPO', startTime, traceId },
+                        fn: () => __awaiter(this, void 0, void 0, function* () {
+                            var _e;
+                            return client.signMessage({
+                                accountAddress,
+                                authToken: (_e = this.getAuthToken) === null || _e === void 0 ? void 0 : _e.call(this),
+                                message: message,
+                                mfaToken,
+                                password,
+                                signedSessionId,
+                                traceContext: {
+                                    startTime,
+                                    traceId,
+                                },
+                            });
+                        }),
+                        operation: 'signMessage',
+                        resource: 'client.signMessage',
+                    });
+                    return signature;
+                }),
+                signTransaction: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _f;
+                    const traceId = this.generateTraceId();
+                    const startTime = Date.now();
+                    this.instrument('[signTransaction] start', {
+                        accountAddress,
+                        chainName: 'TEMPO',
+                        key: 'signTransaction-start',
+                        startTime,
+                        time: 0,
+                        traceId,
+                    });
+                    const mfaToken = yield ((_f = this.getMfaToken) === null || _f === void 0 ? void 0 : _f.call(this, {
+                        mfaAction: MFAAction.WalletWaasSign,
+                    }));
+                    const password = yield this.getPasswordIfNeeded({ accountAddress });
+                    // Ensure chainId is set so the signed transaction matches the RPC's chain (EIP-155).
+                    // Wrong chainId causes "invalid signature: Failed to recover the signer" on broadcast.
+                    const { currentChainId } = this;
+                    const transactionWithChainId = currentChainId !== undefined
+                        ? Object.assign(Object.assign({}, transaction), { chainId: currentChainId }) : transaction;
+                    const tx = yield this.instrumentAsync({
+                        context: { chainName: 'TEMPO', startTime, traceId },
+                        fn: () => __awaiter(this, void 0, void 0, function* () {
+                            var _g;
+                            return client.signTransaction(Object.assign(Object.assign({ authToken: (_g = this.getAuthToken) === null || _g === void 0 ? void 0 : _g.call(this) }, (currentChainId !== undefined && {
+                                chainId: currentChainId.toString(),
+                            })), { mfaToken,
+                                password, senderAddress: accountAddress, signedSessionId, traceContext: {
+                                    startTime,
+                                    traceId,
+                                }, transaction: serializeTransaction(transactionWithChainId) }));
+                        }),
+                        operation: 'signTransaction',
+                        resource: 'client.signTransaction',
+                    });
+                    return tx;
+                }),
+                signTypedData: (typedData) => __awaiter(this, void 0, void 0, function* () {
+                    var _h;
+                    const traceId = this.generateTraceId();
+                    const startTime = Date.now();
+                    this.instrument('[signTypedData] start', {
+                        accountAddress,
+                        chainName: 'TEMPO',
+                        key: 'signTypedData-start',
+                        startTime,
+                        time: 0,
+                        traceId,
+                    });
+                    const mfaToken = yield ((_h = this.getMfaToken) === null || _h === void 0 ? void 0 : _h.call(this, {
+                        mfaAction: MFAAction.WalletWaasSign,
+                    }));
+                    const password = yield this.getPasswordIfNeeded({ accountAddress });
+                    const signature = yield this.instrumentAsync({
+                        context: { chainName: 'TEMPO', startTime, traceId },
+                        fn: () => __awaiter(this, void 0, void 0, function* () {
+                            var _j;
+                            return client.signTypedData({
+                                accountAddress,
+                                authToken: (_j = this.getAuthToken) === null || _j === void 0 ? void 0 : _j.call(this),
+                                mfaToken,
+                                password,
+                                signedSessionId,
+                                traceContext: {
+                                    startTime,
+                                    traceId,
+                                },
+                                typedData: typedData,
+                            });
+                        }),
+                        operation: 'signTypedData',
+                        resource: 'client.signTypedData',
+                    });
+                    return signature;
+                }),
+            };
+        });
+    }
+    getViemAccount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            const accountSource = yield this.getViemAccountCustomSource({
+                accountAddress,
+            });
+            return toAccount(accountSource);
+        });
+    }
+    getWalletClient(chainId) {
+        var _a, _b;
+        const targetAccountAddress = (_a = this.getActiveAccount()) === null || _a === void 0 ? void 0 : _a.address;
+        if (!targetAccountAddress) {
+            return undefined;
+        }
+        // Resolve the network first, then get RPC URL from that network
+        // This ensures the RPC URL matches the resolved chain when chainId is provided
+        const evmNetwork = chainId
+            ? this.getEvmNetworkByChainId(parseInt(chainId))
+            : this.currentEvmNetwork();
+        if (!evmNetwork) {
+            throw new Error(ERROR_TEMPO_NETWORK_NOT_FOUND);
+        }
+        const rpcUrl = ((_b = evmNetwork.privateCustomerRpcUrls) === null || _b === void 0 ? void 0 : _b[0]) || evmNetwork.rpcUrls[0];
+        return createWalletClientWithUiConfirmation({
+            account: () => __awaiter(this, void 0, void 0, function* () {
+                return this.getViemAccount({
+                    accountAddress: targetAccountAddress,
+                });
+            }),
+            address: targetAccountAddress,
+            chain: getOrMapViemChain(evmNetwork),
+            transport: http(rpcUrl, this.providersConfig.httpTransportConfig),
+            walletConnector: this,
+            walletUiUtils: this.walletUiUtils,
+        });
+    }
+    getPublicClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const evmNetwork = this.currentEvmNetwork();
+            if (!evmNetwork) {
+                throw new DynamicError(ERROR_TEMPO_NETWORK_NOT_FOUND);
+            }
+            const rpcUrl = ((_a = evmNetwork.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) || evmNetwork.rpcUrls[0];
+            return createPublicClient({
+                chain: getOrMapViemChain(evmNetwork),
+                transport: http(rpcUrl, this.providersConfig.httpTransportConfig),
+            });
+        });
+    }
+    signMessage(message) {
+        var _a;
+        return (_a = this.getWalletClient()) === null || _a === void 0 ? void 0 : _a.signMessage({ message });
+    }
+    signMessageWithContext(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ message, context, }) {
+            var _b, _c, _d, _e;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield ((_b = this.getSignedSessionId) === null || _b === void 0 ? void 0 : _b.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError(ERROR_SIGNED_SESSION_ID_REQUIRED);
+            }
+            const accountAddress = (_c = this.getActiveAccount()) === null || _c === void 0 ? void 0 : _c.address;
+            const mfaToken = yield ((_d = this.getMfaToken) === null || _d === void 0 ? void 0 : _d.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({ accountAddress });
+            const traceId = this.generateTraceId();
+            const startTime = Date.now();
+            this.instrument('[signMessageWithContext] start', {
+                key: 'signMessageWithContext-start',
+                startTime,
+                time: 0,
+                traceId,
+            });
+            return walletClient.signMessage({
+                accountAddress,
+                authToken: (_e = this.getAuthToken) === null || _e === void 0 ? void 0 : _e.call(this),
+                context,
+                message,
+                mfaToken,
+                password,
+                signedSessionId,
+                traceContext: {
+                    startTime,
+                    traceId,
+                },
+            });
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWalletClient();
+        });
+    }
+    getWalletClientByAddress({ accountAddress, }) {
+        this.setActiveAccount(accountAddress);
+        return this.getWalletClient();
+    }
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const walletClient = this.getWalletClient();
+            const publicClient = yield this.getPublicClient();
+            if (!publicClient || !walletClient) {
+                throw new DynamicError('No public client available');
+            }
+            const uiTransaction = new ViemUiTransaction({
+                account: from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c;
+                    // Build native Tempo type 118 transaction with fee token support
+                    const chainId = yield this.getNetwork();
+                    if (!chainId) {
+                        throw new DynamicError('No chain ID available');
+                    }
+                    // Build the call data for the transaction
+                    const callData = transaction.nonNativeAddress
+                        ? {
+                            // TIP-20/ERC-20 transfer - encode the transfer call
+                            data: encodeFunctionData({
+                                abi: erc20Abi,
+                                args: [
+                                    transaction.to,
+                                    transaction.nonNativeValue,
+                                ],
+                                functionName: 'transfer',
+                            }),
+                            to: transaction.nonNativeAddress,
+                            value: BigInt(0),
+                        }
+                        : {
+                            // Native transfer (Tempo has no native token, but handle for compatibility)
+                            data: '0x',
+                            to: (transaction.to || ''),
+                            value: (_a = transaction.value) !== null && _a !== void 0 ? _a : BigInt(0),
+                        };
+                    // Get standard sequential nonce
+                    const nonce = yield publicClient.getTransactionCount({
+                        address: from,
+                    });
+                    // Estimate gas for the call
+                    const gasEstimate = yield publicClient.estimateGas({
+                        account: from,
+                        data: callData.data,
+                        to: callData.to,
+                        value: callData.value,
+                    });
+                    // Add 30% buffer for Tempo AA overhead + 300k minimum floor for nonce lane init
+                    const gasWithBuffer = (gasEstimate * BigInt(130)) / BigInt(100);
+                    const minGas = BigInt(300000);
+                    const gas = gasWithBuffer > minGas ? gasWithBuffer : minGas;
+                    // Get gas price
+                    const gasPrice = yield publicClient.getGasPrice();
+                    // Build Tempo transaction with proper types (BigInt values)
+                    const tempoTx = Object.assign({ calls: [callData], chainId,
+                        gas, maxFeePerGas: gasPrice, maxPriorityFeePerGas: gasPrice / BigInt(10), nonce }, (transaction.feeTokenAddress && {
+                        feeToken: transaction.feeTokenAddress,
+                    }));
+                    // Get WaaS client and sign the native Tempo transaction
+                    const waasClient = yield this.getWaasWalletClient();
+                    const signedSessionId = yield ((_b = this.getSignedSessionId) === null || _b === void 0 ? void 0 : _b.call(this));
+                    if (!signedSessionId) {
+                        throw new DynamicError(ERROR_SIGNED_SESSION_ID_REQUIRED);
+                    }
+                    const mfaToken = yield ((_c = this.getMfaToken) === null || _c === void 0 ? void 0 : _c.call(this, {
+                        mfaAction: MFAAction.WalletWaasSign,
+                    }));
+                    const password = yield this.getPasswordIfNeeded({
+                        accountAddress: from,
+                    });
+                    const traceId = this.generateTraceId();
+                    const startTime = Date.now();
+                    // Sign the Tempo transaction
+                    const signature = yield this.instrumentAsync({
+                        context: { chainName: 'TEMPO', startTime, traceId },
+                        fn: () => __awaiter(this, void 0, void 0, function* () {
+                            var _d;
+                            return waasClient.signTransaction({
+                                authToken: (_d = this.getAuthToken) === null || _d === void 0 ? void 0 : _d.call(this),
+                                mfaToken,
+                                password,
+                                senderAddress: from,
+                                signedSessionId,
+                                traceContext: {
+                                    startTime,
+                                    traceId,
+                                },
+                                // Use replacer to convert BigInt to string for JSON serialization
+                                transaction: JSON.stringify(tempoTx, (_, v) => typeof v === 'bigint' ? v.toString() : v),
+                            });
+                        }),
+                        operation: 'signTempoTransaction',
+                        resource: 'waasClient.signTransaction',
+                    });
+                    // Broadcast using sendRawTransaction
+                    const hash = yield publicClient.sendRawTransaction({
+                        serializedTransaction: signature,
+                    });
+                    return hash;
+                }),
+                publicClient,
+                transaction: {},
+            });
+            uiTransaction.chain = 'TEMPO';
+            uiTransaction.getBalance = () => Promise.resolve(BigInt(0));
+            // Mark as "gas sponsored" so insufficient funds check doesn't compare
+            // native balance (0) vs gas fees - Tempo fees are paid in TIP-20 tokens
+            uiTransaction.isGasSponsored = () => true;
+            return uiTransaction;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const verifiedCredentials = this.verifiedCredentials || [];
+            const addresses = verifiedCredentials
+                .map((vc) => vc === null || vc === void 0 ? void 0 : vc.address)
+                .filter((a) => typeof a === 'string');
+            if (addresses.length > 0 && ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address)) {
+                this.setActiveAccount(this.verifiedCredential.address);
+            }
+            return addresses;
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const activeAccount = this.getActiveAccount();
+            if (!activeAccount || !activeAccount.address) {
+                // If no active account, try to get one from verified credentials
+                if ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address) {
+                    const { address } = this.verifiedCredential;
+                    this.setActiveAccount(address);
+                    return address;
+                }
+                throw new DynamicError('No active wallet address found');
+            }
+            return activeAccount.address;
+        });
+    }
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.endSession.call(this);
+        });
+    }
+}
+DynamicWaasTempoConnector.lastUsedChainIdStorageKey = 'dynamic-waas-tempo-last-used-chain-id';
+
+export { DynamicWaasTempoConnector };

package/src/connectors/DynamicWaasTempoConnector/index.cjs

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

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

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

package/src/connectors/DynamicWaasTempoConnector/index.js

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

package/src/connectors/TempoWalletConnector/TempoWalletConnector.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ethereumCore = require('@dynamic-labs/ethereum-core');
+
+/**
+ * Base wallet connector for Tempo chain.
+ * Extends EthereumWalletConnector since Tempo is EVM-compatible,
+ * but sets connectedChain to 'TEMPO' for proper routing to the Tempo wallet client.
+ * Uses tempoNetworks instead of evmNetworks for proper network display.
+ */
+class TempoWalletConnector extends ethereumCore.EthereumWalletConnector {
+    constructor(props) {
+        // Pass tempoNetworks as evmNetworks to parent since EthereumWalletConnector expects evmNetworks
+        super(Object.assign(Object.assign({}, props), { evmNetworks: props.tempoNetworks }));
+        this.supportedChains = ['TEMPO'];
+        this.connectedChain = 'TEMPO';
+    }
+    /**
+     * Override getBalance to return '0' for Tempo networks.
+     * Tempo is an EVM-compatible chain with no native token - fees are paid in TIP-20 stablecoins.
+     * Calling eth_getBalance returns garbage data, so we return '0' instead.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return '0';
+        });
+    }
+}
+
+exports.TempoWalletConnector = TempoWalletConnector;

package/src/connectors/TempoWalletConnector/TempoWalletConnector.d.ts

@@ -0,0 +1,23 @@
+import { EthereumWalletConnector, EthereumWalletConnectorOpts } from '@dynamic-labs/ethereum-core';
+import { GenericNetwork } from '@dynamic-labs/types';
+import { Chain } from '@dynamic-labs/wallet-connector-core';
+export type TempoWalletConnectorOpts = Omit<EthereumWalletConnectorOpts, 'evmNetworks'> & {
+    tempoNetworks: GenericNetwork[];
+};
+/**
+ * Base wallet connector for Tempo chain.
+ * Extends EthereumWalletConnector since Tempo is EVM-compatible,
+ * but sets connectedChain to 'TEMPO' for proper routing to the Tempo wallet client.
+ * Uses tempoNetworks instead of evmNetworks for proper network display.
+ */
+export declare abstract class TempoWalletConnector extends EthereumWalletConnector {
+    supportedChains: Chain[];
+    connectedChain: Chain;
+    constructor(props: TempoWalletConnectorOpts);
+    /**
+     * Override getBalance to return '0' for Tempo networks.
+     * Tempo is an EVM-compatible chain with no native token - fees are paid in TIP-20 stablecoins.
+     * Calling eth_getBalance returns garbage data, so we return '0' instead.
+     */
+    getBalance(address: string): Promise<string>;
+}

package/src/connectors/TempoWalletConnector/TempoWalletConnector.js

@@ -0,0 +1,31 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { EthereumWalletConnector } from '@dynamic-labs/ethereum-core';
+
+/**
+ * Base wallet connector for Tempo chain.
+ * Extends EthereumWalletConnector since Tempo is EVM-compatible,
+ * but sets connectedChain to 'TEMPO' for proper routing to the Tempo wallet client.
+ * Uses tempoNetworks instead of evmNetworks for proper network display.
+ */
+class TempoWalletConnector extends EthereumWalletConnector {
+    constructor(props) {
+        // Pass tempoNetworks as evmNetworks to parent since EthereumWalletConnector expects evmNetworks
+        super(Object.assign(Object.assign({}, props), { evmNetworks: props.tempoNetworks }));
+        this.supportedChains = ['TEMPO'];
+        this.connectedChain = 'TEMPO';
+    }
+    /**
+     * Override getBalance to return '0' for Tempo networks.
+     * Tempo is an EVM-compatible chain with no native token - fees are paid in TIP-20 stablecoins.
+     * Calling eth_getBalance returns garbage data, so we return '0' instead.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return '0';
+        });
+    }
+}
+
+export { TempoWalletConnector };

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

@@ -0,0 +1,2 @@
+export { TempoWalletConnector } from './TempoWalletConnector';
+export type { TempoWalletConnectorOpts } from './TempoWalletConnector';