@dynamic-labs/ton 4.60.0 → 4.61.0

package/src/connectors/TonConnectConnector/TonConnectConnector.js

@@ -0,0 +1,705 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { TonConnect } from '@tonconnect/sdk';
+import { Address, beginCell, Cell, loadStateInit } from '@ton/core';
+import { TonClient, fromNano } from '@ton/ton';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { TonWallet } from '../../wallet/TonWallet/TonWallet.js';
+import { debugLogMultiline, debugLogWithLevel, debugLog } from '../../utils/debugLog/debugLog.js';
+import { TonUiTransaction, NANOTON_PER_TON } from '../../utils/TonUiTransaction/TonUiTransaction.js';
+import { prepareTonTransfer } from '../../utils/prepareTonTransfer/prepareTonTransfer.js';
+import { prepareJettonTransfer } from '../../utils/prepareJettonTransfer/prepareJettonTransfer.js';
+
+/**
+ * TON Connect connector implementation
+ *
+ * Uses the TON Connect SDK to connect with TON wallets that support
+ * the TON Connect protocol (Tonkeeper, MyTonWallet, etc.)
+ */
+class TonConnectConnector extends WalletConnectorBase {
+    /**
+     * Get the TonConnect instance (for discovering wallets and advanced usage)
+     */
+    getTonConnect() {
+        if (!this.tonConnect) {
+            const manifestUrl = typeof window !== 'undefined'
+                ? `${window.location.origin}/tonconnect-manifest.json`
+                : 'https://dynamic.xyz/tonconnect-manifest.json';
+            // Debug logging
+            debugLogMultiline([
+                '[TON Connect] Initializing TonConnect with manifest URL:',
+                manifestUrl,
+            ], [
+                '[TON Connect] Current origin:',
+                typeof window !== 'undefined' ? window.location.origin : 'SSR',
+            ]);
+            this.tonConnect = new TonConnect({
+                manifestUrl,
+            });
+        }
+        return this.tonConnect;
+    }
+    /**
+     * Creates a new TON Connect connector
+     *
+     * @param opts - Configuration options
+     */
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = TonWallet;
+        this.name = 'TON Connect';
+        this.overrideKey = 'tonconnect';
+        this.connectedChain = 'TON';
+        this.supportedChains = ['TON'];
+        this.canConnectViaQrCode = true;
+        this.connectedWallet = null;
+        this.pendingProofPayload = null;
+        this.tonNetworks = opts.tonNetworks || [];
+        this.overrideKey = opts.overrideKey || 'tonconnect';
+        // Only initialize TonConnect in browser environment
+        // This prevents SSR errors and allows the connector to be created
+        if (typeof window !== 'undefined') {
+            try {
+                const manifestUrl = opts.manifestUrl ||
+                    `${window.location.origin}/tonconnect-manifest.json`;
+                // Debug logging
+                debugLogMultiline(['[TON Connect] Constructor - manifest URL:', manifestUrl], [
+                    '[TON Connect] Constructor - window.location:',
+                    { href: window.location.href, origin: window.location.origin },
+                ]);
+                this.tonConnect = new TonConnect({
+                    manifestUrl,
+                });
+            }
+            catch (error) {
+                // If TonConnect fails to initialize, set to null and initialize lazily
+                logger.error('[TON Connect] Failed to initialize TonConnect:', error);
+                debugLogWithLevel('error', '[TON Connect] Constructor - Error initializing:', error);
+                this.tonConnect = null;
+            }
+        }
+        else {
+            // For SSR, tonConnect will be null and initialized lazily in getTonConnect()
+            this.tonConnect = null;
+        }
+    }
+    /**
+     * Setup event listeners for TON Connect
+     */
+    setupEventListeners() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const tonConnect = this.getTonConnect();
+        tonConnect.onStatusChange((wallet) => {
+            if (wallet) {
+                this.connectedWallet = wallet;
+                const userFriendlyAddress = this.convertAddressToUserFriendly(wallet.account.address);
+                this.emit('accountChange', { accounts: [userFriendlyAddress] });
+            }
+            else {
+                this.connectedWallet = null;
+                this.emit('disconnect');
+            }
+        });
+    }
+    /**
+     * Check if TON Connect is available
+     */
+    isInstalledOnBrowser() {
+        // TON Connect wallets are mobile apps, not browser extensions
+        // Return false so they show as QR code/deep link wallets
+        return false;
+    }
+    /**
+     * Connect to a TON wallet
+     * @param tonProofPayload - Optional payload for tonProof authentication
+     */
+    connect(tonProofPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tonConnect = this.getTonConnect();
+                // If already connected, return early
+                if (tonConnect.connected) {
+                    return;
+                }
+                // Get available wallets
+                const wallets = yield tonConnect.getWallets();
+                if (wallets.length === 0) {
+                    throw new DynamicError('No TON wallets available');
+                }
+                const matchingWallet = this.findMatchingWallet(wallets);
+                if (!matchingWallet) {
+                    throw new DynamicError(`TON wallet "${this.overrideKey}" not found in available wallets`);
+                }
+                try {
+                    // Use provided payload or pending payload for tonProof
+                    const proofPayload = tonProofPayload || this.pendingProofPayload;
+                    const connectOptions = proofPayload
+                        ? { request: { tonProof: proofPayload } }
+                        : undefined;
+                    tonConnect.connect(matchingWallet, connectOptions);
+                }
+                catch (error) {
+                    debugLogWithLevel('error', '[TON Connect] Error during connect:', error);
+                    throw error;
+                }
+            }
+            catch (error) {
+                if (this.isUserRejectionError(error)) {
+                    throw new DynamicError('User rejected connection');
+                }
+                logger.error('[TON Connect] Connection failed:', error);
+                throw new DynamicError(`Failed to connect to TON wallet: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Find a wallet matching this connector's overrideKey
+     */
+    findMatchingWallet(wallets) {
+        const overrideKeyLower = this.overrideKey.toLowerCase();
+        return (wallets.find((wallet) => wallet.appName.toLowerCase() === overrideKeyLower ||
+            wallet.name.toLowerCase() === overrideKeyLower) ||
+            wallets.find((wallet) => wallet.appName.toLowerCase().startsWith(overrideKeyLower) ||
+                wallet.name.toLowerCase().startsWith(overrideKeyLower)) ||
+            wallets.find((wallet) => wallet.appName.toLowerCase().includes(overrideKeyLower) ||
+                wallet.name.toLowerCase().includes(overrideKeyLower)));
+    }
+    /**
+     * Get the current wallet address in user-friendly format (EQ... or UQ...)
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const tonConnect = this.getTonConnect();
+            // If already connected, return the address immediately
+            if (tonConnect.connected && ((_a = tonConnect.account) === null || _a === void 0 ? void 0 : _a.address)) {
+                return this.convertAddressToUserFriendly(tonConnect.account.address);
+            }
+            // If not connected, initiate connection and wait for it to complete
+            try {
+                // Start the connection process (shows QR code/deep link)
+                yield this.connect();
+                // After connect() returns, the QR code is shown but connection is not yet established
+                // Wait for the connection to be established by polling or waiting for status change
+                // TON Connect SDK doesn't provide a clean way to wait, so we poll
+                const maxWaitTime = 300000; // 5 minutes
+                const pollInterval = 500; // Check every 500ms
+                const startTime = Date.now();
+                while (!tonConnect.connected && Date.now() - startTime < maxWaitTime) {
+                    yield new Promise((resolve) => setTimeout(resolve, pollInterval));
+                    // Check if connected after the delay
+                    if (tonConnect.connected && ((_b = tonConnect.account) === null || _b === void 0 ? void 0 : _b.address)) {
+                        const userFriendlyAddress = this.convertAddressToUserFriendly(tonConnect.account.address);
+                        return userFriendlyAddress;
+                    }
+                }
+                // If we get here, either timeout or still not connected
+                if (!tonConnect.connected) {
+                    throw new DynamicError('Connection timeout - user did not approve the connection');
+                }
+                const rawAddress = (_c = tonConnect.account) === null || _c === void 0 ? void 0 : _c.address;
+                return rawAddress
+                    ? this.convertAddressToUserFriendly(rawAddress)
+                    : undefined;
+            }
+            catch (error) {
+                logger.error('[TON Connect] Failed to get address:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Get connected accounts
+     */
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const tonConnect = this.getTonConnect();
+            if (!tonConnect.connected || !((_a = tonConnect.account) === null || _a === void 0 ? void 0 : _a.address)) {
+                return [];
+            }
+            return [this.convertAddressToUserFriendly(tonConnect.account.address)];
+        });
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const tonConnect = this.getTonConnect();
+            if (!tonConnect.connected) {
+                return '-239'; // Mainnet default (chain ID -239)
+            }
+            const { account } = tonConnect;
+            // TON mainnet chain ID is -239, testnet is -3
+            return ((_a = account === null || account === void 0 ? void 0 : account.chain) === null || _a === void 0 ? void 0 : _a.toString()) || '-239';
+        });
+    }
+    /**
+     * Check if current network is testnet
+     */
+    isTestnet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const network = yield this.getNetwork();
+            // TON testnet chain ID is -3
+            return network === '-3';
+        });
+    }
+    /**
+     * Sign a message
+     */
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tonConnect = this.getTonConnect();
+            if (!tonConnect.connected) {
+                throw new DynamicError('Wallet not connected');
+            }
+            try {
+                const result = yield tonConnect.signData({
+                    text: messageToSign,
+                    type: 'text',
+                });
+                return result.signature;
+            }
+            catch (error) {
+                if (this.isUserRejectionError(error)) {
+                    throw new DynamicError('User rejected message signing');
+                }
+                logger.error('[TON Connect] Sign message failed:', error);
+                throw new DynamicError(`Failed to sign message: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Send a transaction
+     */
+    sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tonConnect = this.getTonConnect();
+            if (!tonConnect.connected) {
+                throw new DynamicError('Wallet not connected');
+            }
+            try {
+                // Convert addresses from raw format (0:hex) to user-friendly format (EQ...)
+                // TON Connect SDK expects user-friendly format for message addresses
+                const messages = request.messages.map((message) => (Object.assign(Object.assign({}, message), { address: this.convertAddressToUserFriendly(message.address) })));
+                // 'from' is omitted as TonConnect uses the connected wallet's address
+                const transactionRequest = {
+                    messages,
+                    network: request.network,
+                    validUntil: request.validUntil || Math.floor(Date.now() / 1000) + 300, // 5 minutes from now
+                };
+                const result = yield tonConnect.sendTransaction(transactionRequest);
+                return {
+                    boc: result.boc,
+                    hash: result.boc, // TON Connect returns boc as the transaction identifier
+                };
+            }
+            catch (error) {
+                if (this.isUserRejectionError(error)) {
+                    throw new DynamicError('User rejected transaction');
+                }
+                logger.error('[TON Connect] Send transaction failed:', error);
+                throw new DynamicError(`Failed to send transaction: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * Send Jetton transaction
+     */
+    sendJettonTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Jetton transfers require constructing a specific message
+            // This is a simplified version - full implementation would need
+            // to construct the proper Jetton transfer message
+            throw new DynamicError('Jetton transfers not yet implemented');
+        });
+    }
+    /**
+     * Get TonClient for the current or specified network.
+     */
+    getTonClient(chainId) {
+        var _a, _b, _c, _d, _e;
+        const targetChainId = chainId || ((_b = (_a = this.tonNetworks) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.chainId);
+        const network = (_c = this.tonNetworks) === null || _c === void 0 ? void 0 : _c.find((net) => net.chainId === targetChainId);
+        if (!network) {
+            throw new DynamicError(`Network configuration not found for chainId: ${targetChainId}`);
+        }
+        const endpoint = ((_d = network.privateCustomerRpcUrls) === null || _d === void 0 ? void 0 : _d[0]) || ((_e = network.rpcUrls) === null || _e === void 0 ? void 0 : _e[0]);
+        if (!endpoint) {
+            throw new DynamicError(`No RPC endpoint found for chainId: ${targetChainId}`);
+        }
+        return new TonClient({ endpoint });
+    }
+    /**
+     * Get balance of an address
+     */
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = this.getTonClient();
+                const tonAddress = Address.parse(address);
+                const balanceNano = yield client.getBalance(tonAddress);
+                const balance = fromNano(balanceNano);
+                return balance;
+            }
+            catch (error) {
+                logger.error('[TON Connect] Failed to get balance:', error);
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Get enabled networks
+     */
+    getEnabledNetworks() {
+        return this.tonNetworks;
+    }
+    /**
+     * Switch network (TON Connect handles this automatically)
+     */
+    switchNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TON Connect manages network switching through the wallet UI
+            throw new DynamicError('Network switching must be done manually in the TON wallet');
+        });
+    }
+    /**
+     * Disconnect and cleanup
+     */
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tonConnect = this.getTonConnect();
+                if (tonConnect.connected) {
+                    yield tonConnect.disconnect();
+                }
+            }
+            catch (error) {
+                logger.debug('[TON Connect] Error during disconnect:', error);
+            }
+        });
+    }
+    /**
+     * Create a UI transaction for the send balance flow
+     */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const client = this.getTonClient();
+            return new TonUiTransaction({
+                client,
+                from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () { return this.internalSendUiTransaction(transaction); }),
+            });
+        });
+    }
+    /**
+     * Internal handler for UI transaction submission
+     */
+    internalSendUiTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!transaction.to) {
+                throw new DynamicError('Destination address is required');
+            }
+            const tonConnect = this.getTonConnect();
+            if (!tonConnect.connected || !((_a = tonConnect.account) === null || _a === void 0 ? void 0 : _a.address)) {
+                throw new DynamicError('Wallet not connected');
+            }
+            const walletAddress = this.convertAddressToUserFriendly(tonConnect.account.address);
+            const client = this.getTonClient();
+            const network = tonConnect.account.chain;
+            // Jetton (non-native token) transfers
+            // TODO: Test it when token balances are implemented
+            if (transaction.nonNativeAddress && transaction.nonNativeValue) {
+                const request = yield prepareJettonTransfer({
+                    client,
+                    forwardTonAmount: BigInt(0),
+                    jettonAmount: transaction.nonNativeValue,
+                    jettonMasterAddress: transaction.nonNativeAddress,
+                    network,
+                    recipientAddress: transaction.to,
+                    timeout: 60,
+                    walletAddress,
+                });
+                const result = yield this.sendTransaction(request);
+                return result.boc || result.hash || '';
+            }
+            // Native TON transfers
+            if (transaction.value) {
+                const tonAmount = Number(transaction.value) / NANOTON_PER_TON;
+                const request = yield prepareTonTransfer({
+                    amount: tonAmount,
+                    client,
+                    network,
+                    recipient: transaction.to,
+                    timeout: 60,
+                    walletAddress,
+                });
+                const result = yield this.sendTransaction(request);
+                return result.boc || result.hash || '';
+            }
+            throw new DynamicError('Invalid transaction parameters');
+        });
+    }
+    /**
+     * Convert TON address from raw format (0:hex) to user-friendly format (UQ...)
+     * TON Connect SDK expects user-friendly format for message addresses
+     */
+    convertAddressToUserFriendly(address) {
+        var _a;
+        try {
+            if (address.startsWith('EQ') || address.startsWith('UQ')) {
+                return address;
+            }
+            // Detect if testnet from connected wallet
+            const tonConnect = this.getTonConnect();
+            const isTestnet = ((_a = tonConnect.account) === null || _a === void 0 ? void 0 : _a.chain) === '-3';
+            // Convert from raw format (0:hex) to user-friendly format
+            return Address.parse(address).toString({
+                bounceable: false,
+                testOnly: isTestnet,
+                urlSafe: true,
+            });
+        }
+        catch (error) {
+            // If parsing fails, return original address
+            logger.debug('[TON Connect] Failed to convert address format:', error);
+            return address;
+        }
+    }
+    /**
+     * Encode a comment as TON message payload
+     *
+     * TON comments are encoded as a Cell with:
+     * - First 32 bits (4 bytes): 0x00000000 (comment opcode)
+     * - Then the UTF-8 bytes of the comment
+     *
+     * For long messages, the comment is split across multiple cells using references.
+     * The Cell is then serialized to base64 BOC format for TON Connect SDK
+     */
+    encodeComment(comment) {
+        const encoder = new TextEncoder();
+        const commentBytes = encoder.encode(comment);
+        // TON Cell can hold max 1023 bits
+        // We use 32 bits for the opcode, leaving ~991 bits (~123 bytes) for data
+        // For longer messages, we split into multiple cells using references
+        const maxBytesPerCell = 123; // Conservative estimate to avoid overflow
+        if (commentBytes.length <= maxBytesPerCell) {
+            // Short message fits in one cell
+            const cell = beginCell()
+                .storeUint(0, 32) // Comment opcode
+                .storeBuffer(Buffer.from(commentBytes))
+                .endCell();
+            return cell.toBoc().toString('base64');
+        }
+        // Long message: split across multiple cells
+        // First cell: opcode + first chunk
+        // Remaining chunks go in reference cells
+        const firstChunk = commentBytes.slice(0, maxBytesPerCell);
+        const remainingBytes = commentBytes.slice(maxBytesPerCell);
+        // Build reference cells for remaining data
+        let remainingData = remainingBytes;
+        // Create cells for remaining data (each can hold ~127 bytes)
+        const referenceCells = [];
+        while (remainingData.length > 0) {
+            const chunk = remainingData.slice(0, 127);
+            remainingData = remainingData.slice(127);
+            referenceCells.push(beginCell().storeBuffer(Buffer.from(chunk)).endCell());
+        }
+        // Build the main cell with opcode, first chunk, and references
+        let mainCellBuilder = beginCell()
+            .storeUint(0, 32) // Comment opcode
+            .storeBuffer(Buffer.from(firstChunk));
+        // Add reference cells
+        for (const refCell of referenceCells) {
+            mainCellBuilder = mainCellBuilder.storeRef(refCell);
+        }
+        const mainCell = mainCellBuilder.endCell();
+        // Serialize to base64 BOC (Bag of Cells) format
+        return mainCell.toBoc().toString('base64');
+    }
+    /**
+     * Check if error is a user rejection
+     */
+    isUserRejectionError(error) {
+        return (error !== null &&
+            typeof error === 'object' &&
+            'name' in error &&
+            error.name === 'UserRejectsError');
+    }
+    /**
+     * Generate a TON Connect proof for authentication
+     * @param payload - The payload string to include in the proof
+     * @returns TON Connect proof object
+     */
+    generateTonConnectProof(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const tonConnect = this.getTonConnect();
+            // If already connected with a proof, return it
+            if ((_b = (_a = this.connectedWallet) === null || _a === void 0 ? void 0 : _a.connectItems) === null || _b === void 0 ? void 0 : _b.tonProof) {
+                const { tonProof } = this.connectedWallet.connectItems;
+                if ('proof' in tonProof) {
+                    debugLog('[TON Connect] Returning existing proof from connection');
+                    return {
+                        address: this.connectedWallet.account.address,
+                        domain: tonProof.proof.domain,
+                        payload: tonProof.proof.payload,
+                        signature: tonProof.proof.signature,
+                        timestamp: tonProof.proof.timestamp,
+                    };
+                }
+            }
+            // If connected but no proof, disconnect and reconnect with proof
+            if (tonConnect.connected) {
+                debugLog('[TON Connect] Already connected without proof, disconnecting to reconnect with tonProof');
+                yield tonConnect.disconnect();
+                this.connectedWallet = null;
+            }
+            // Store the payload for the connect call
+            this.pendingProofPayload = payload;
+            // Connect with tonProof
+            yield this.connect(payload);
+            // Wait for the connection to be established with the proof
+            const maxWaitTime = 300000; // 5 minutes
+            const pollInterval = 500;
+            const startTime = Date.now();
+            while (Date.now() - startTime < maxWaitTime) {
+                yield new Promise((resolve) => setTimeout(resolve, pollInterval));
+                if (tonConnect.connected &&
+                    ((_d = (_c = tonConnect.wallet) === null || _c === void 0 ? void 0 : _c.connectItems) === null || _d === void 0 ? void 0 : _d.tonProof) &&
+                    'proof' in tonConnect.wallet.connectItems.tonProof) {
+                    this.connectedWallet = tonConnect.wallet;
+                    const { tonProof } = tonConnect.wallet.connectItems;
+                    // Clear the pending payload
+                    this.pendingProofPayload = null;
+                    return {
+                        address: tonConnect.wallet.account.address,
+                        domain: tonProof.proof.domain,
+                        payload: tonProof.proof.payload,
+                        signature: tonProof.proof.signature,
+                        timestamp: tonProof.proof.timestamp,
+                    };
+                }
+                // Check if connected but proof was rejected or not supported
+                if (tonConnect.connected && !((_f = (_e = tonConnect.wallet) === null || _e === void 0 ? void 0 : _e.connectItems) === null || _f === void 0 ? void 0 : _f.tonProof)) {
+                    this.pendingProofPayload = null;
+                    throw new DynamicError('Wallet connected but did not provide proof. The wallet may not support tonProof.');
+                }
+            }
+            this.pendingProofPayload = null;
+            throw new DynamicError('Connection timeout - user did not approve the connection');
+        });
+    }
+    /**
+     * Override proveOwnership to use tonProof for wallet verification
+     *
+     * For TON wallets, we use the tonProof mechanism during connection
+     * which is the standard way to prove wallet ownership in TON Connect.
+     * The backend expects a specific format with state_init and public_key.
+     */
+    proveOwnership(address, messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(address);
+            return this.proveOwnershipWithTonProof(messageToSign);
+        });
+    }
+    /**
+     * proveOwnership using tonProof
+     *
+     * Returns the proof in the format expected by the backend:
+     * {
+     *   address: string,
+     *   proof: { domain, payload, signature, state_init, timestamp },
+     *   public_key: string
+     * }
+     */
+    proveOwnershipWithTonProof(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Extract the nonce from the SIWE message to use as tonProof payload
+            // The tonProof payload has a 128 byte limit, so we can't use the full message
+            const payload = this.extractNonceFromMessage(messageToSign);
+            // Use tonProof for authentication - this ensures we have connectedWallet set
+            const proof = yield this.generateTonConnectProof(payload);
+            // Get state_init from the connected wallet account
+            const stateInit = (_a = this.connectedWallet) === null || _a === void 0 ? void 0 : _a.account.walletStateInit;
+            if (!stateInit) {
+                throw new DynamicError('Wallet did not provide state_init required for verification');
+            }
+            // Get public key from wallet - this is the key that signed the proof
+            // The wallet provides this in account.publicKey (hex without 0x prefix)
+            const walletProvidedKey = (_b = this.connectedWallet) === null || _b === void 0 ? void 0 : _b.account.publicKey;
+            const publicKey = walletProvidedKey || this.extractPublicKeyFromStateInit(stateInit);
+            return JSON.stringify({
+                address: proof.address,
+                proof: {
+                    domain: proof.domain,
+                    payload: proof.payload,
+                    signature: proof.signature,
+                    state_init: stateInit,
+                    timestamp: proof.timestamp,
+                },
+                public_key: publicKey,
+            });
+        });
+    }
+    /**
+     * Extract public key from state_init cell
+     *
+     * For standard TON wallets, the public key is stored in the data cell:
+     * - First 32 bits: seqno (skipped)
+     * - Next 256 bits (32 bytes): public key
+     *
+     * This matches the extraction logic in the backend.
+     */
+    extractPublicKeyFromStateInit(stateInitBase64) {
+        try {
+            const cell = Cell.fromBase64(stateInitBase64);
+            const stateInit = loadStateInit(cell.beginParse());
+            const dataCell = stateInit.data;
+            if (!dataCell) {
+                throw new Error('No data cell in state_init');
+            }
+            const dataSlice = dataCell.beginParse();
+            // Skip first 32 bits (seqno for most wallets)
+            dataSlice.loadUint(32);
+            // Next 256 bits (32 bytes) is the public key
+            const publicKeyBuffer = dataSlice.loadBuffer(32);
+            // Convert to hex string (no 0x prefix, as expected by backend)
+            const hexKey = Buffer.from(publicKeyBuffer).toString('hex');
+            return hexKey;
+        }
+        catch (error) {
+            logger.error('[TON Connect] Failed to extract public key from state_init:', error);
+            debugLog('[TON Connect] state_init that failed:', stateInitBase64);
+            throw new DynamicError('Failed to extract public key from wallet state_init');
+        }
+    }
+    /**
+     * Extract the nonce from a SIWE-style message
+     *
+     * @param message - The full message to extract nonce from
+     * @returns A short payload suitable for tonProof
+     */
+    extractNonceFromMessage(message) {
+        const nonceMatch = message.match(/Nonce:\s*([^\n\r]+)/i);
+        if (nonceMatch === null || nonceMatch === void 0 ? void 0 : nonceMatch[1]) {
+            const nonce = nonceMatch[1].trim();
+            if (nonce.length <= 128) {
+                return nonce;
+            }
+        }
+        return message.slice(0, 64);
+    }
+}
+
+export { TonConnectConnector };