@eos3/connect 0.1.4 → 0.1.9

package/README.md

@@ -24,28 +24,40 @@ It does not bundle Telegram's script into the main SDK bundle; call
 ```ts
 import {
   createEosConnect,
-  getEosConnectTelegramWebApp,
   isEosConnectError,
-  loadEosConnectTelegramWebAppSdk,
   normalizeEosConnectError
 } from '@eos3/connect';
 
-await loadEosConnectTelegramWebAppSdk().catch(() => undefined);
-const telegramWebApp = getEosConnectTelegramWebApp();
-
 const eosConnect = createEosConnect({
   network: 'testnet',
   apiBaseUrl: 'https://your-wallet-api.example.com',
   botUsername: 'your_bot',
   locale: 'zh-CN',
-  telegramWebApp
+  defaultConnectOptions: {
+    replaceWallet: true,
+    assetLimits: [
+      {
+        tokenContract: 'core.vaulta',
+        symbol: 'A',
+        precision: 4,
+        perTxLimit: '1',
+        dailyLimit: '10',
+        totalBudget: '100'
+      }
+    ]
+  }
 });
 
 eosConnect.subscribe((state) => {
   console.log('EOS wallet state:', state);
 });
 
-await eosConnect.checkWallet();
+await eosConnect.bootstrapTelegram();
+const quickPay = await eosConnect.checkQuickPay();
+
+if (!quickPay.enabled) {
+  await eosConnect.enableQuickPay();
+}
 ```
 
 `network` can be `testnet` or `mainnet`. It selects browser signing RPC
@@ -58,13 +70,14 @@ When `botUsername` is set, the SDK sends it as `x-telegram-bot-username` so a
 shared backend can choose the correct Telegram bot token for `initData`
 verification.
 
-`connectTelegram()` opens the `bindUrl` returned by the API. The API should
+`enableQuickPay()`, `startTelegramWalletFlow()`, and `connectTelegram()` open the `bindUrl` returned by the API. The API should
 generate that URL from its `WEB_BASE_URL`, so users leave the Mini App and finish
 passkey authentication on the hosted passkey binding page.
 
 ## Internationalization
 
-The built-in payment confirmation sheet supports English and Simplified Chinese.
+Quick payment labels, Wallet ViewModel text, and the built-in payment confirmation sheet support
+English and Simplified Chinese.
 The SDK uses explicit `locale`, then Telegram `language_code`, then
 `navigator.language`, and falls back to English:
 
@@ -73,12 +86,53 @@ const eosConnect = createEosConnect({
   telegramWebApp,
   locale: 'zh-CN',
   messages: {
+    walletSetupTitle: '开启钱包',
     paymentConfirmTitle: '确认付款',
     paymentConfirmAction: '支付'
   }
 });
 ```
 
+## Quick Payment Flow
+
+For app UIs, prefer `checkQuickPay()` and `enableQuickPay()`. They hide
+low-level wallet capability statuses such as `needs_local_key`, open pending
+bind URLs, rebind the current device when the local payment key is missing, and
+can poll until quick payment is enabled:
+
+```ts
+const quickPay = await eosConnect.checkQuickPay();
+
+renderQuickPay({
+  enabled: quickPay.enabled,
+  account: quickPay.account,
+  balance: quickPay.balance,
+  buttonLabel: quickPay.enabled ? '快捷支付已开启' : '开启快捷支付'
+});
+
+if (!quickPay.enabled) {
+  const next = await eosConnect.enableQuickPay({
+    pollIntervalMs: 1500,
+    timeoutMs: 120_000
+  });
+  renderQuickPay(next);
+}
+```
+
+`enableQuickPay()` performs the common Telegram setup sequence:
+
+- loads Telegram's WebApp SDK when needed;
+- initializes `BiometricManager` and checks SecureStorage support;
+- calls `checkWallet()`;
+- opens an existing `pending` `bindUrl`;
+- calls `connectTelegram({ replaceWallet: true })` when the current device is
+  missing the local payment key;
+- polls wallet readiness until `ready`, another terminal state, or timeout.
+
+Advanced UIs can still call `getWalletView()` or `startTelegramWalletFlow()`
+when they need debug-level states and labels. Pass `waitForReady: false` if
+your UI should return immediately after opening the binding page.
+
 ## Connect a Telegram Wallet
 
 ```ts
@@ -220,11 +274,17 @@ await fetch('https://wallet.example.com/api/market/push', {
 - `client.getProviders()`: returns wallet provider metadata.
 - `client.getSnapshot()`: returns the current state.
 - `client.subscribe(listener)`: subscribes to state changes.
+- `client.bootstrapTelegram()`: loads Telegram WebApp SDK, initializes biometrics, and checks secure storage support.
 - `client.restore()`: loads wallet state from the API.
+- `client.refreshWallet()`: refreshes wallet readiness and returns a UI-ready ViewModel.
 - `client.checkWallet()`: checks server wallet plus local key readiness.
+- `client.checkQuickPay()`: returns `{ enabled, account, balance, reason }` for business UI.
+- `client.getWalletView()`: returns the current wallet ViewModel for app UIs.
 - `checkEosConnectTelegramPayStorage(app)`: initializes Telegram biometrics and returns secure storage diagnostics.
 - `client.connectTelegram(options)`: starts or resumes Telegram binding.
 - `client.connectTokenPocket(options)`: starts TokenPocket binding.
+- `client.startTelegramWalletFlow(options)`: runs the high-level Telegram wallet setup flow.
+- `client.enableQuickPay(options)`: runs the high-level setup flow and returns quick payment readiness.
 - `client.pay(options)`: builds, signs, confirms, and pushes a paylimit payment.
 - `client.disconnect()`: removes the local Telegram payment key from
   SecureStorage, clears the biometric token, and resets the SDK state.

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+export type EosConnectErrorCode = 'DAILY_LIMIT_EXCEEDED' | 'PER_TX_LIMIT_EXCEEDED' | 'TOTAL_BUDGET_EXCEEDED' | 'INSUFFICIENT_BALANCE' | 'RAM_INSUFFICIENT' | 'PAYMENT_PERMISSION_MISSING' | 'SIGNATURE_REJECTED' | 'SESSION_EXPIRED' | 'NETWORK_ERROR' | 'UNKNOWN_CHAIN_ERROR';
+export declare class EosConnectError extends Error {
+    readonly code: EosConnectErrorCode;
+    readonly rawMessage: string;
+    readonly retryable: boolean;
+    constructor(code: EosConnectErrorCode, message: string, options?: {
+        rawMessage?: string;
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare function isEosConnectError(error: unknown): error is EosConnectError;
+export declare function normalizeEosConnectError(error: unknown): EosConnectError;
+export declare function rawErrorMessage(error: unknown): string;

package/dist/errors.js

@@ -0,0 +1,143 @@
+export class EosConnectError extends Error {
+    code;
+    rawMessage;
+    retryable;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'EosConnectError';
+        this.code = code;
+        this.rawMessage = options.rawMessage ?? message;
+        this.retryable = options.retryable ?? false;
+        if (options.cause !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+}
+export function isEosConnectError(error) {
+    return error instanceof EosConnectError;
+}
+export function normalizeEosConnectError(error) {
+    if (isEosConnectError(error)) {
+        return error;
+    }
+    const rawMessage = rawErrorMessage(error);
+    const normalized = rawMessage.toLowerCase();
+    if (normalized.includes('daily limit exceeded')) {
+        return new EosConnectError('DAILY_LIMIT_EXCEEDED', '今日支付额度已用完，请明天再试或提高每日额度。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('per-transfer limit exceeded') ||
+        normalized.includes('per transfer limit exceeded') ||
+        normalized.includes('per_tx_limit') ||
+        normalized.includes('single transfer limit')) {
+        return new EosConnectError('PER_TX_LIMIT_EXCEEDED', '本次支付超过单笔额度，请降低金额或提高单笔额度。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('total budget exceeded')) {
+        return new EosConnectError('TOTAL_BUDGET_EXCEEDED', '该权限的总预算已用完，请调整总预算后再试。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('overdrawn balance') ||
+        normalized.includes('insufficient balance') ||
+        normalized.includes('balance is insufficient')) {
+        return new EosConnectError('INSUFFICIENT_BALANCE', '余额不足，请充值后再试。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('ram usage') ||
+        normalized.includes('billed ram') ||
+        normalized.includes('insufficient ram') ||
+        normalized.includes('current ram usage limit')) {
+        return new EosConnectError('RAM_INSUFFICIENT', '账号 RAM 不足，请补充 RAM 后再试。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('bot permission is inactive') ||
+        normalized.includes('permission does not match bot authorization') ||
+        normalized.includes('paylimit code authority is missing') ||
+        normalized.includes('missing from transfer permission') ||
+        normalized.includes('transaction declares authority') ||
+        normalized.includes('missing authority')) {
+        return new EosConnectError('PAYMENT_PERMISSION_MISSING', '快捷支付权限未绑定或已失效，请重新绑定后再试。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('not signed in') ||
+        normalized.includes('invalid session') ||
+        normalized.includes('session user not found') ||
+        normalized.includes('telegram initdata is missing') ||
+        normalized.includes('telegram session not found')) {
+        return new EosConnectError('SESSION_EXPIRED', '登录状态已失效，请重新打开小程序或重新登录。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('notallowederror') ||
+        normalized.includes('aborterror') ||
+        normalized.includes('payment confirmation was cancelled') ||
+        normalized.includes('biometric authentication failed') ||
+        normalized.includes('user cancelled')) {
+        return new EosConnectError('SIGNATURE_REJECTED', '已取消签名确认，支付未提交。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('open this wallet in the telegram mobile app') ||
+        normalized.includes('secure biometric key storage') ||
+        normalized.includes('securestorage is not available') ||
+        normalized.includes('secure storage is not available')) {
+        return new EosConnectError('SIGNATURE_REJECTED', '请在 Telegram 手机客户端打开，当前设备不支持安全存储。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('biometric unlock key is missing') ||
+        normalized.includes('quick key is missing')) {
+        return new EosConnectError('PAYMENT_PERMISSION_MISSING', '当前设备缺少本地支付密钥，请重新绑定。', {
+            rawMessage,
+            cause: error
+        });
+    }
+    if (normalized.includes('failed to fetch') ||
+        normalized.includes('network') ||
+        normalized.includes('all eos rpc nodes failed') ||
+        normalized.includes('eos rpc') ||
+        normalized.includes('timeout')) {
+        return new EosConnectError('NETWORK_ERROR', '网络连接失败，请稍后重试。', {
+            rawMessage,
+            retryable: true,
+            cause: error
+        });
+    }
+    return new EosConnectError('UNKNOWN_CHAIN_ERROR', '支付失败，请稍后重试或联系服务方。', {
+        rawMessage,
+        cause: error
+    });
+}
+export function rawErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object') {
+        const maybeError = error;
+        if (typeof maybeError.error === 'string') {
+            return maybeError.error;
+        }
+        if (typeof maybeError.message === 'string') {
+            return maybeError.message;
+        }
+    }
+    return 'EOS Connect request failed';
+}

package/dist/http.d.ts

@@ -0,0 +1,3 @@
+import { EosConnectError } from './errors.js';
+export declare function parseResponseBody(response: Response): Promise<unknown>;
+export declare function normalizeHttpResponseError(response: Response, body: unknown): EosConnectError;

package/dist/http.js

@@ -0,0 +1,40 @@
+import { EosConnectError, normalizeEosConnectError, rawErrorMessage } from './errors.js';
+export async function parseResponseBody(response) {
+    try {
+        return await response.json();
+    }
+    catch (jsonError) {
+        if (typeof response.text === 'function') {
+            const text = await response.text().catch(() => '');
+            if (text) {
+                return text;
+            }
+        }
+        throw jsonError;
+    }
+}
+function httpStatusMessage(response) {
+    const status = typeof response.status === 'number' ? response.status : 0;
+    const statusText = response.statusText ? ` ${response.statusText}` : '';
+    return status ? `HTTP ${status}${statusText}` : 'HTTP request failed';
+}
+function bodyMessage(body) {
+    if (typeof body === 'string') {
+        return body.replace(/\s+/g, ' ').trim();
+    }
+    return rawErrorMessage(body);
+}
+export function normalizeHttpResponseError(response, body) {
+    if (body && typeof body === 'object') {
+        return normalizeEosConnectError(body);
+    }
+    const rawMessage = `${httpStatusMessage(response)}: ${bodyMessage(body)}`.trim();
+    const status = typeof response.status === 'number' ? response.status : 0;
+    if (status >= 500) {
+        return new EosConnectError('NETWORK_ERROR', '网络连接失败，请稍后重试。', {
+            rawMessage,
+            retryable: true
+        });
+    }
+    return normalizeEosConnectError(rawMessage);
+}

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import type { PayLimitAssetConfig, PayLimitPayment, SignedTransferPayload } from '@eos3/shared';
+import { type EosConnectTelegramWebApp } from './telegram-web-app.js';
+export { EosConnectError, isEosConnectError, normalizeEosConnectError, type EosConnectErrorCode } from './errors.js';
+export { EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL, getEosConnectTelegramWebApp, loadEosConnectTelegramWebAppSdk, type EosConnectTelegramWebApp } from './telegram-web-app.js';
 export type EosConnectProviderId = 'telegram' | 'tokenpocket' | 'anchor';
 export type EosConnectProviderState = 'available' | 'coming_soon' | 'disabled';
 export type EosConnectStatus = 'idle' | 'not_connected' | 'pending' | 'connected' | 'unsupported' | 'error';
@@ -12,41 +15,6 @@ export interface EosConnectProvider {
     state: EosConnectProviderState;
     description: string;
 }
-export interface EosConnectTelegramWebApp {
-    initData?: string;
-    initDataUnsafe?: {
-        user?: {
-            language_code?: string;
-        };
-    };
-    platform?: string;
-    version?: string;
-    openLink?(url: string): void;
-    SecureStorage?: {
-        setItem(key: string, value: string, callback?: (error: string | null, isStored?: boolean) => void): void;
-        getItem(key: string, callback: (error: string | null, value?: string | null) => void): void;
-        removeItem?(key: string, callback?: (error: string | null, isRemoved?: boolean) => void): void;
-    };
-    BiometricManager?: {
-        isInited?: boolean;
-        isBiometricAvailable?: boolean;
-        isAccessRequested?: boolean;
-        isAccessGranted?: boolean;
-        isBiometricTokenSaved?: boolean;
-        init(callback?: () => void): void;
-        requestAccess?(params: {
-            reason?: string;
-        }, callback?: (isGranted: boolean) => void): void;
-        authenticate(params: {
-            reason?: string;
-        }, callback: (isAuthenticated: boolean, biometricToken?: string) => void): void;
-        updateBiometricToken(token: string, callback?: (isUpdated: boolean) => void): void;
-        openSettings?(): void;
-    };
-}
-export declare const EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL = "https://telegram.org/js/telegram-web-app.js";
-export declare function getEosConnectTelegramWebApp(): EosConnectTelegramWebApp | null;
-export declare function loadEosConnectTelegramWebAppSdk(doc?: Document | null | undefined): Promise<void>;
 export interface EosConnectState {
     status: EosConnectStatus;
     provider: EosConnectProviderId | null;
@@ -102,9 +70,11 @@ export interface EosConnectOptions {
     network?: EosConnectNetwork;
     apiBaseUrl?: string;
     botUsername?: string;
+    tokenPocketSource?: string;
     deviceLabel?: string;
     locale?: string;
     messages?: EosConnectMessages;
+    defaultConnectOptions?: EosConnectTelegramOptions;
     balanceAsset?: EosConnectBalanceAsset;
     rpcUrls?: string | string[];
     signTransaction?: EosConnectTransactionSigner;
@@ -127,15 +97,51 @@ export interface EosConnectTelegramOptions {
     replaceWallet?: boolean;
     openLink?: boolean;
 }
+export interface EosConnectWalletFlowOptions extends EosConnectTelegramOptions {
+    waitForReady?: boolean;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    openExternal?: (url: string) => void;
+}
+export type EosConnectWalletViewStatus = 'setup' | 'pending' | 'ready' | 'unsupported' | 'error';
+export type EosConnectWalletViewAction = 'start_wallet_flow' | 'open_bind_url' | 'pay' | 'none';
+export interface EosConnectWalletViewPrimaryAction {
+    label: string;
+    action: EosConnectWalletViewAction;
+    disabled?: boolean;
+}
+export interface EosConnectWalletView {
+    status: EosConnectWalletViewStatus;
+    account: string | null;
+    balance: string | null;
+    canPay: boolean;
+    title: string;
+    description: string;
+    primaryAction: EosConnectWalletViewPrimaryAction;
+    bindUrl: string | null;
+    reason: string | null;
+}
+export interface EosConnectQuickPayStatus {
+    enabled: boolean;
+    account: string | null;
+    balance: string | null;
+    reason: string | null;
+}
 export interface EosConnectClient {
     getProviders(): EosConnectProvider[];
     getSnapshot(): EosConnectState;
     subscribe(listener: (state: EosConnectState) => void): () => void;
+    bootstrapTelegram(): Promise<EosConnectTelegramPayStorageCheck>;
     restore(): Promise<EosConnectState>;
+    refreshWallet(): Promise<EosConnectWalletView>;
     checkWallet(): Promise<EosConnectWalletCapability>;
+    checkQuickPay(): Promise<EosConnectQuickPayStatus>;
+    getWalletView(): Promise<EosConnectWalletView>;
     connect(options: EosConnectConnectOptions): Promise<EosConnectState>;
     connectTelegram(options?: EosConnectTelegramOptions): Promise<EosConnectState>;
     connectTokenPocket(options?: EosConnectTelegramOptions): Promise<EosConnectState>;
+    startTelegramWalletFlow(options?: EosConnectWalletFlowOptions): Promise<EosConnectWalletView>;
+    enableQuickPay(options?: EosConnectWalletFlowOptions): Promise<EosConnectQuickPayStatus>;
     pay(options: EosConnectPayOptions): Promise<EosConnectPayResult>;
     disconnect(): Promise<EosConnectState>;
 }
@@ -169,18 +175,6 @@ export interface EosConnectPayResult {
     ok: true;
     txid: string;
 }
-export type EosConnectErrorCode = 'DAILY_LIMIT_EXCEEDED' | 'PER_TX_LIMIT_EXCEEDED' | 'TOTAL_BUDGET_EXCEEDED' | 'INSUFFICIENT_BALANCE' | 'RAM_INSUFFICIENT' | 'PAYMENT_PERMISSION_MISSING' | 'SIGNATURE_REJECTED' | 'SESSION_EXPIRED' | 'NETWORK_ERROR' | 'UNKNOWN_CHAIN_ERROR';
-export declare class EosConnectError extends Error {
-    readonly code: EosConnectErrorCode;
-    readonly rawMessage: string;
-    readonly retryable: boolean;
-    constructor(code: EosConnectErrorCode, message: string, options?: {
-        rawMessage?: string;
-        retryable?: boolean;
-        cause?: unknown;
-    });
-}
-export declare function isEosConnectError(error: unknown): error is EosConnectError;
 export interface EosConnectPaymentDetails {
     intentId: string;
     chainId: string;
@@ -194,6 +188,18 @@ export interface EosConnectPaymentDetails {
 export type EosConnectSignedTransaction = SignedTransferPayload;
 export type EosConnectPaymentConfirmer = (details: EosConnectPaymentDetails) => boolean | Promise<boolean>;
 export interface EosConnectMessages {
+    walletSetupTitle?: string;
+    walletSetupDescription?: string;
+    walletReadyTitle?: string;
+    walletReadyDescription?: string;
+    walletPendingTitle?: string;
+    walletPendingDescription?: string;
+    walletUnsupportedTitle?: string;
+    walletUnsupportedDescription?: string;
+    walletErrorTitle?: string;
+    walletActionStart?: string;
+    walletActionContinue?: string;
+    walletActionPay?: string;
     paymentConfirmTitle?: string;
     paymentConfirmClose?: string;
     paymentConfirmRecipient?: string;
@@ -227,8 +233,7 @@ export declare function checkEosConnectTelegramPayStorage(app: EosConnectTelegra
 export declare function initEosConnectTelegramBiometricManager(app: EosConnectTelegramWebApp, timeoutMs?: number): Promise<boolean>;
 export declare function openEosConnectTelegramBiometricSettings(app: EosConnectTelegramWebApp): Promise<EosConnectTelegramBiometricSettingsResult>;
 export declare function eosConnectWalletSetupState(wallet: EosConnectWalletInfo, env?: EosConnectWalletSetupEnv): EosConnectWalletSetupState;
-export declare function normalizeEosConnectError(error: unknown): EosConnectError;
-export declare function tokenPocketDappUrl(url: string): string;
+export declare function tokenPocketDappUrl(url: string, source?: string): string;
 export declare function generateEosConnectPaymentKey(): Promise<{
     privateKey: string;
     publicKey: string;

package/dist/index.js

@@ -1,59 +1,9 @@
 import { ABI, PrivateKey, Serializer, Transaction } from '@wharfkit/antelope';
-export const EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL = 'https://telegram.org/js/telegram-web-app.js';
-let telegramWebAppSdkLoadPromise = null;
-export function getEosConnectTelegramWebApp() {
-    const maybeGlobal = globalThis;
-    return maybeGlobal.window?.Telegram?.WebApp ?? maybeGlobal.Telegram?.WebApp ?? null;
-}
-export function loadEosConnectTelegramWebAppSdk(doc = globalThis.document) {
-    if (getEosConnectTelegramWebApp()) {
-        return Promise.resolve();
-    }
-    if (telegramWebAppSdkLoadPromise) {
-        return telegramWebAppSdkLoadPromise;
-    }
-    if (!doc?.head) {
-        return Promise.reject(new Error('Document is not available to load Telegram WebApp SDK'));
-    }
-    telegramWebAppSdkLoadPromise = new Promise((resolve, reject) => {
-        const finish = () => resolve();
-        const fail = () => {
-            telegramWebAppSdkLoadPromise = null;
-            reject(new Error('Failed to load Telegram WebApp SDK'));
-        };
-        const existing = doc.querySelector(`script[src="${EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL}"]`);
-        if (existing) {
-            existing.addEventListener('load', finish, { once: true });
-            existing.addEventListener('error', fail, { once: true });
-            return;
-        }
-        const script = doc.createElement('script');
-        script.src = EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL;
-        script.async = true;
-        script.onload = finish;
-        script.onerror = fail;
-        doc.head.appendChild(script);
-    });
-    return telegramWebAppSdkLoadPromise;
-}
-export class EosConnectError extends Error {
-    code;
-    rawMessage;
-    retryable;
-    constructor(code, message, options = {}) {
-        super(message);
-        this.name = 'EosConnectError';
-        this.code = code;
-        this.rawMessage = options.rawMessage ?? message;
-        this.retryable = options.retryable ?? false;
-        if (options.cause !== undefined) {
-            this.cause = options.cause;
-        }
-    }
-}
-export function isEosConnectError(error) {
-    return error instanceof EosConnectError;
-}
+import { normalizeHttpResponseError, parseResponseBody } from './http.js';
+import { getEosConnectTelegramWebApp, loadEosConnectTelegramWebAppSdk } from './telegram-web-app.js';
+export { EosConnectError, isEosConnectError, normalizeEosConnectError } from './errors.js';
+import { normalizeEosConnectError } from './errors.js';
+export { EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL, getEosConnectTelegramWebApp, loadEosConnectTelegramWebAppSdk } from './telegram-web-app.js';
 const defaultWalletSetupEnv = {
     hasTelegramSession: true,
     canStorePayKey: true
@@ -437,117 +387,20 @@ function paymentDetailsFromBuiltTransfer(built) {
         payments
     };
 }
-export function normalizeEosConnectError(error) {
-    if (isEosConnectError(error)) {
-        return error;
-    }
-    const rawMessage = rawErrorMessage(error);
-    const normalized = rawMessage.toLowerCase();
-    if (normalized.includes('daily limit exceeded')) {
-        return new EosConnectError('DAILY_LIMIT_EXCEEDED', '今日支付额度已用完，请明天再试或提高每日额度。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('per-transfer limit exceeded') ||
-        normalized.includes('per transfer limit exceeded') ||
-        normalized.includes('per_tx_limit') ||
-        normalized.includes('single transfer limit')) {
-        return new EosConnectError('PER_TX_LIMIT_EXCEEDED', '本次支付超过单笔额度，请降低金额或提高单笔额度。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('total budget exceeded')) {
-        return new EosConnectError('TOTAL_BUDGET_EXCEEDED', '该权限的总预算已用完，请调整总预算后再试。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('overdrawn balance') ||
-        normalized.includes('insufficient balance') ||
-        normalized.includes('balance is insufficient')) {
-        return new EosConnectError('INSUFFICIENT_BALANCE', '余额不足，请充值后再试。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('ram usage') ||
-        normalized.includes('billed ram') ||
-        normalized.includes('insufficient ram') ||
-        normalized.includes('current ram usage limit')) {
-        return new EosConnectError('RAM_INSUFFICIENT', '账号 RAM 不足，请补充 RAM 后再试。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('bot permission is inactive') ||
-        normalized.includes('permission does not match bot authorization') ||
-        normalized.includes('paylimit code authority is missing') ||
-        normalized.includes('missing from transfer permission') ||
-        normalized.includes('transaction declares authority') ||
-        normalized.includes('missing authority')) {
-        return new EosConnectError('PAYMENT_PERMISSION_MISSING', '快捷支付权限未绑定或已失效，请重新绑定后再试。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('not signed in') ||
-        normalized.includes('invalid session') ||
-        normalized.includes('session user not found') ||
-        normalized.includes('telegram initdata is missing') ||
-        normalized.includes('telegram session not found')) {
-        return new EosConnectError('SESSION_EXPIRED', '登录状态已失效，请重新打开小程序或重新登录。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('notallowederror') ||
-        normalized.includes('aborterror') ||
-        normalized.includes('payment confirmation was cancelled') ||
-        normalized.includes('biometric authentication failed') ||
-        normalized.includes('user cancelled')) {
-        return new EosConnectError('SIGNATURE_REJECTED', '已取消签名确认，支付未提交。', {
-            rawMessage,
-            cause: error
-        });
-    }
-    if (normalized.includes('failed to fetch') ||
-        normalized.includes('network') ||
-        normalized.includes('all eos rpc nodes failed') ||
-        normalized.includes('eos rpc') ||
-        normalized.includes('timeout')) {
-        return new EosConnectError('NETWORK_ERROR', '网络连接失败，请稍后重试。', {
-            rawMessage,
-            retryable: true,
-            cause: error
-        });
-    }
-    return new EosConnectError('UNKNOWN_CHAIN_ERROR', '支付失败，请稍后重试或联系服务方。', {
-        rawMessage,
-        cause: error
-    });
-}
-function rawErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === 'string') {
-        return error;
-    }
-    if (error && typeof error === 'object') {
-        const maybeError = error;
-        if (typeof maybeError.error === 'string') {
-            return maybeError.error;
-        }
-        if (typeof maybeError.message === 'string') {
-            return maybeError.message;
-        }
-    }
-    return 'EOS Connect request failed';
-}
 const EOS_CONNECT_MESSAGES = {
     en: {
+        walletSetupTitle: 'Enable quick payment',
+        walletSetupDescription: 'Complete one binding, then eligible payments can be confirmed quickly.',
+        walletReadyTitle: 'Wallet connected',
+        walletReadyDescription: 'Quick payment is enabled.',
+        walletPendingTitle: 'Continue wallet binding',
+        walletPendingDescription: 'Finish the security confirmation in the opened binding page.',
+        walletUnsupportedTitle: 'Open in Telegram mobile',
+        walletUnsupportedDescription: 'Telegram initData and secure storage are required.',
+        walletErrorTitle: 'Wallet unavailable',
+        walletActionStart: 'Enable quick payment',
+        walletActionContinue: 'Continue binding',
+        walletActionPay: 'Pay',
         paymentConfirmTitle: 'Payment details',
         paymentConfirmClose: 'Close',
         paymentConfirmRecipient: 'Recipient',
@@ -557,6 +410,18 @@ const EOS_CONNECT_MESSAGES = {
         emptyMemo: '-'
     },
     'zh-CN': {
+        walletSetupTitle: '开启快捷支付',
+        walletSetupDescription: '完成一次绑定，符合额度的支付可快速确认',
+        walletReadyTitle: '钱包已连接',
+        walletReadyDescription: '快捷支付已开启',
+        walletPendingTitle: '继续完成绑定',
+        walletPendingDescription: '请在打开的页面完成安全绑定。',
+        walletUnsupportedTitle: '请在 Telegram 手机端打开',
+        walletUnsupportedDescription: '需要 Telegram initData 和安全存储能力。',
+        walletErrorTitle: '钱包暂不可用',
+        walletActionStart: '开启快捷支付',
+        walletActionContinue: '继续绑定',
+        walletActionPay: '去支付',
         paymentConfirmTitle: '交易详情',
         paymentConfirmClose: '关闭',
         paymentConfirmRecipient: '收款地址',
@@ -696,8 +561,9 @@ function ensurePaymentConfirmStyle(documentRef) {
 }
 function defaultConfirmPayment(details, options) {
     const documentRef = globalThis.document;
-    if (!documentRef?.body)
-        return Promise.resolve(true);
+    if (!documentRef?.body) {
+        return Promise.reject(new Error('Payment confirmation UI is not available. Pass confirmPayment: false to skip it explicitly.'));
+    }
     ensurePaymentConfirmStyle(documentRef);
     const message = (key) => eosConnectMessage(key, options.locale, options.messages);
     const backdrop = documentRef.createElement('div');
@@ -775,11 +641,11 @@ function parseRpcUrls(raw) {
     }
     return urls;
 }
-export function tokenPocketDappUrl(url) {
+export function tokenPocketDappUrl(url, source = 'eosconnect') {
     return `tpdapp://open?params=${encodeURIComponent(JSON.stringify({
         url,
         chain: 'EOS',
-        source: 'eospasskey'
+        source
     }))}`;
 }
 export async function generateEosConnectPaymentKey() {
@@ -812,11 +678,17 @@ function randomBase64Url(byteLength) {
     return base64UrlEncode(bytes);
 }
 function requireSecureTelegramStorage(app) {
-    if (!app?.SecureStorage || !app.BiometricManager?.updateBiometricToken) {
+    if (!app?.SecureStorage || !app.BiometricManager) {
         throw new Error(TELEGRAM_MOBILE_REQUIRED);
     }
     return app;
 }
+function requireTelegramMethod(method, name) {
+    if (typeof method !== 'function') {
+        throw new Error(`Telegram ${name} is not available`);
+    }
+    return method;
+}
 async function importUnlockKey(unlockKey) {
     return crypto.subtle.importKey('raw', arrayBuffer(base64UrlDecode(unlockKey)), { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
 }
@@ -842,9 +714,12 @@ async function decryptPrivateKey(envelope, unlockKey) {
 }
 async function ensureBiometricAccess(app) {
     const biometric = app.BiometricManager;
-    if (!biometric?.updateBiometricToken) {
+    if (!biometric) {
         throw new Error(TELEGRAM_MOBILE_REQUIRED);
     }
+    requireTelegramMethod(biometric?.init, 'BiometricManager.init');
+    requireTelegramMethod(biometric?.authenticate, 'BiometricManager.authenticate');
+    requireTelegramMethod(biometric?.updateBiometricToken, 'BiometricManager.updateBiometricToken');
     if (!biometric.isInited) {
         await new Promise((resolve) => biometric.init(resolve));
     }
@@ -864,8 +739,9 @@ async function ensureBiometricAccess(app) {
     }
 }
 function secureStorageSet(app, key, value) {
+    const setItem = requireTelegramMethod(app.SecureStorage?.setItem, 'SecureStorage.setItem');
     return new Promise((resolve, reject) => {
-        app.SecureStorage?.setItem(key, value, (error, isStored) => {
+        setItem.call(app.SecureStorage, key, value, (error, isStored) => {
             if (error) {
                 reject(new Error(error));
                 return;
@@ -879,8 +755,9 @@ function secureStorageSet(app, key, value) {
     });
 }
 function secureStorageGet(app, key) {
+    const getItem = requireTelegramMethod(app.SecureStorage?.getItem, 'SecureStorage.getItem');
     return new Promise((resolve, reject) => {
-        app.SecureStorage?.getItem(key, (error, value) => {
+        getItem.call(app.SecureStorage, key, (error, value) => {
             if (error) {
                 reject(new Error(error));
                 return;
@@ -890,8 +767,9 @@ function secureStorageGet(app, key) {
     });
 }
 function updateBiometricToken(app, token) {
+    const update = requireTelegramMethod(app.BiometricManager?.updateBiometricToken, 'BiometricManager.updateBiometricToken');
     return new Promise((resolve, reject) => {
-        app.BiometricManager?.updateBiometricToken(token, (isUpdated) => {
+        update.call(app.BiometricManager, token, (isUpdated) => {
             if (isUpdated) {
                 resolve();
             }
@@ -902,8 +780,9 @@ function updateBiometricToken(app, token) {
     });
 }
 function authenticateForUnlock(app) {
+    const authenticate = requireTelegramMethod(app.BiometricManager?.authenticate, 'BiometricManager.authenticate');
     return new Promise((resolve, reject) => {
-        app.BiometricManager?.authenticate({ reason: 'Unlock EOS signing key' }, (isAuthenticated, biometricToken) => {
+        authenticate.call(app.BiometricManager, { reason: 'Unlock EOS signing key' }, (isAuthenticated, biometricToken) => {
             if (!isAuthenticated) {
                 reject(new Error('Biometric authentication failed'));
                 return;
@@ -932,7 +811,8 @@ function secureStorageRemove(app, key) {
             });
             return;
         }
-        app.SecureStorage?.setItem(key, '', (error, isStored) => {
+        const setItem = requireTelegramMethod(app.SecureStorage?.setItem, 'SecureStorage.setItem');
+        setItem.call(app.SecureStorage, key, '', (error, isStored) => {
             if (error) {
                 reject(new Error(error));
                 return;
@@ -953,7 +833,13 @@ export async function saveEosConnectPaymentKey(privateKey, app) {
     envelope.publicKey = await publicKeyFromEosPrivateKey(privateKey);
     envelope.createdAt = new Date().toISOString();
     await secureStorageSet(telegram, EOS_CONNECT_PRIVATE_KEY_STORAGE, JSON.stringify(envelope));
-    await updateBiometricToken(telegram, unlockKey);
+    try {
+        await updateBiometricToken(telegram, unlockKey);
+    }
+    catch (error) {
+        await secureStorageRemove(telegram, EOS_CONNECT_PRIVATE_KEY_STORAGE).catch(() => undefined);
+        throw error;
+    }
 }
 export async function loadEosConnectStoredPublicKey(app) {
     if (!app?.SecureStorage) {
@@ -1251,6 +1137,146 @@ function notConnectedWalletCapability(reason = null) {
         wallet: null
     };
 }
+function pendingWalletCapabilityFromState(state) {
+    return {
+        status: 'pending',
+        hasWallet: Boolean(state.hasWallet),
+        canUse: false,
+        needsLocalKey: false,
+        account: state.account,
+        balance: state.balance,
+        bindId: state.bindId,
+        bindUrl: state.bindUrl,
+        expectedPublicKey: null,
+        localPublicKey: null,
+        reason: state.error,
+        wallet: null
+    };
+}
+function walletViewFromCapability(capability, message) {
+    if (capability.status === 'ready') {
+        return {
+            status: 'ready',
+            account: capability.account,
+            balance: capability.balance,
+            canPay: true,
+            title: message('walletReadyTitle'),
+            description: message('walletReadyDescription'),
+            primaryAction: {
+                label: message('walletActionPay'),
+                action: 'pay'
+            },
+            bindUrl: null,
+            reason: null
+        };
+    }
+    if (capability.status === 'pending') {
+        return {
+            status: 'pending',
+            account: capability.account,
+            balance: capability.balance,
+            canPay: false,
+            title: message('walletPendingTitle'),
+            description: capability.reason ?? message('walletPendingDescription'),
+            primaryAction: {
+                label: message('walletActionContinue'),
+                action: capability.bindUrl ? 'open_bind_url' : 'none',
+                disabled: !capability.bindUrl
+            },
+            bindUrl: capability.bindUrl,
+            reason: capability.reason
+        };
+    }
+    if (capability.status === 'unsupported') {
+        return {
+            status: 'unsupported',
+            account: null,
+            balance: capability.balance,
+            canPay: false,
+            title: message('walletUnsupportedTitle'),
+            description: capability.reason ?? message('walletUnsupportedDescription'),
+            primaryAction: {
+                label: message('walletActionStart'),
+                action: 'none',
+                disabled: true
+            },
+            bindUrl: null,
+            reason: capability.reason
+        };
+    }
+    return {
+        status: 'setup',
+        account: capability.account,
+        balance: capability.balance,
+        canPay: false,
+        title: message('walletSetupTitle'),
+        description: message('walletSetupDescription'),
+        primaryAction: {
+            label: message('walletActionStart'),
+            action: 'start_wallet_flow'
+        },
+        bindUrl: capability.bindUrl,
+        reason: capability.reason
+    };
+}
+function walletViewFromError(error, message) {
+    return {
+        status: 'error',
+        account: null,
+        balance: null,
+        canPay: false,
+        title: message('walletErrorTitle'),
+        description: error.message,
+        primaryAction: {
+            label: message('walletActionStart'),
+            action: 'start_wallet_flow'
+        },
+        bindUrl: null,
+        reason: error.rawMessage
+    };
+}
+function quickPayFromCapability(capability) {
+    return {
+        enabled: capability.status === 'ready' && capability.canUse,
+        account: capability.account,
+        balance: capability.balance,
+        reason: capability.status === 'ready' && capability.canUse ? null : capability.reason
+    };
+}
+function quickPayFromView(view) {
+    return {
+        enabled: view.canPay,
+        account: view.account,
+        balance: view.balance,
+        reason: view.canPay ? null : view.reason ?? view.description
+    };
+}
+function quickPayFromError(error) {
+    return {
+        enabled: false,
+        account: null,
+        balance: null,
+        reason: error.message
+    };
+}
+function mergeTelegramConnectOptions(defaults, overrides) {
+    return {
+        botUsername: overrides?.botUsername ?? defaults?.botUsername,
+        assetLimits: overrides?.assetLimits ?? defaults?.assetLimits,
+        replaceWallet: overrides?.replaceWallet ?? defaults?.replaceWallet,
+        openLink: overrides?.openLink ?? defaults?.openLink
+    };
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function openFlowUrl(url, clientOptions, flowOptions, telegramWebApp) {
+    if (flowOptions.openExternal) {
+        flowOptions.openExternal(url);
+        return;
+    }
+    openExternalUrl(url, clientOptions, telegramWebApp);
+}
 export function createEosConnect(options) {
     const fetchImpl = options.fetch ?? fetch;
     const networkConfig = options.network ? EOS_CONNECT_NETWORKS[options.network] : null;
@@ -1270,6 +1296,9 @@ export function createEosConnect(options) {
     function initData() {
         return telegramWebApp()?.initData ?? '';
     }
+    function message(key) {
+        return eosConnectMessage(key, resolveEosConnectLocale(options.locale, telegramWebApp()), options.messages);
+    }
     function botUsernameHeader() {
         return options.botUsername ? { 'x-telegram-bot-username': options.botUsername } : {};
     }
@@ -1288,9 +1317,15 @@ export function createEosConnect(options) {
         catch (error) {
             throw normalizeEosConnectError(error);
         }
-        const body = (await response.json());
+        let body;
+        try {
+            body = await parseResponseBody(response);
+        }
+        catch (error) {
+            throw normalizeEosConnectError(error);
+        }
         if (!response.ok) {
-            throw normalizeEosConnectError(body);
+            throw normalizeHttpResponseError(response, body);
         }
         return body;
     }
@@ -1305,6 +1340,31 @@ export function createEosConnect(options) {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
+        async bootstrapTelegram() {
+            await loadEosConnectTelegramWebAppSdk().catch(() => undefined);
+            const app = telegramWebApp();
+            if (!app) {
+                publish({
+                    ...idleState,
+                    status: 'unsupported',
+                    error: 'Telegram WebApp is missing'
+                });
+                return {
+                    supported: false,
+                    biometricInitialized: false,
+                    diagnostics: eosConnectTelegramPayStorageDiagnostics({})
+                };
+            }
+            const check = await checkEosConnectTelegramPayStorage(app);
+            if (!check.supported) {
+                publish({
+                    ...idleState,
+                    status: 'unsupported',
+                    error: TELEGRAM_MOBILE_REQUIRED
+                });
+            }
+            return check;
+        },
         async restore() {
             if (!initData()) {
                 return publish({
@@ -1320,6 +1380,20 @@ export function createEosConnect(options) {
             });
             return publish(walletToState(wallet));
         },
+        async refreshWallet() {
+            try {
+                return walletViewFromCapability(await this.checkWallet(), message);
+            }
+            catch (error) {
+                const normalized = normalizeEosConnectError(error);
+                publish({
+                    ...state,
+                    status: 'error',
+                    error: normalized.message
+                });
+                return walletViewFromError(normalized, message);
+            }
+        },
         async checkWallet() {
             if (!initData()) {
                 const capability = {
@@ -1354,6 +1428,23 @@ export function createEosConnect(options) {
             publish(walletCapabilityToState(capability));
             return capability;
         },
+        async checkQuickPay() {
+            try {
+                return quickPayFromCapability(await this.checkWallet());
+            }
+            catch (error) {
+                const normalized = normalizeEosConnectError(error);
+                publish({
+                    ...state,
+                    status: 'error',
+                    error: normalized.message
+                });
+                return quickPayFromError(normalized);
+            }
+        },
+        async getWalletView() {
+            return this.refreshWallet();
+        },
         async connect(connectOptions) {
             if (connectOptions.provider !== 'telegram' && connectOptions.provider !== 'tokenpocket') {
                 throw new Error(`${providerDisplayName(connectOptions.provider)} is not supported yet`);
@@ -1409,18 +1500,21 @@ export function createEosConnect(options) {
                 error: null
             });
             if (connectOptions.openLink !== false) {
-                openExternalUrl(connectOptions.provider === 'tokenpocket' ? tokenPocketDappUrl(bind.bindUrl) : bind.bindUrl, options, telegramWebApp());
+                openExternalUrl(connectOptions.provider === 'tokenpocket'
+                    ? tokenPocketDappUrl(bind.bindUrl, options.tokenPocketSource)
+                    : bind.bindUrl, options, telegramWebApp());
             }
             return next;
         },
         async connectTelegram(telegramOptions = {}) {
+            const resolvedTelegramOptions = mergeTelegramConnectOptions(options.defaultConnectOptions, telegramOptions);
             const paymentKey = await generateEosConnectPaymentKey();
             const next = await this.connect({
                 provider: 'telegram',
                 publicKey: paymentKey.publicKey,
-                botUsername: telegramOptions.botUsername,
-                assetLimits: telegramOptions.assetLimits,
-                replaceWallet: telegramOptions.replaceWallet,
+                botUsername: resolvedTelegramOptions.botUsername,
+                assetLimits: resolvedTelegramOptions.assetLimits,
+                replaceWallet: resolvedTelegramOptions.replaceWallet,
                 openLink: false
             });
             if (next.hasWallet) {
@@ -1432,11 +1526,75 @@ export function createEosConnect(options) {
             if (!next.reused) {
                 await saveEosConnectPaymentKey(paymentKey.privateKey, telegramWebApp());
             }
-            if (telegramOptions.openLink !== false) {
+            if (resolvedTelegramOptions.openLink !== false) {
                 openExternalUrl(next.bindUrl, options, telegramWebApp());
             }
             return next;
         },
+        async startTelegramWalletFlow(flowOptions = {}) {
+            try {
+                const storage = await this.bootstrapTelegram();
+                if (!storage.supported) {
+                    return walletViewFromCapability({
+                        ...notConnectedWalletCapability(state.error ?? TELEGRAM_MOBILE_REQUIRED),
+                        status: 'unsupported'
+                    }, message);
+                }
+                const resolvedTelegramOptions = mergeTelegramConnectOptions(options.defaultConnectOptions, flowOptions);
+                let capability = await this.checkWallet();
+                let openedView = null;
+                if (capability.status === 'ready' || capability.status === 'unsupported') {
+                    return walletViewFromCapability(capability, message);
+                }
+                if (capability.status === 'pending') {
+                    if (capability.bindUrl && resolvedTelegramOptions.openLink !== false) {
+                        openFlowUrl(capability.bindUrl, options, flowOptions, telegramWebApp());
+                    }
+                    openedView = walletViewFromCapability(capability, message);
+                }
+                else {
+                    const next = await this.connectTelegram({
+                        ...resolvedTelegramOptions,
+                        replaceWallet: capability.needsLocalKey ? true : resolvedTelegramOptions.replaceWallet,
+                        openLink: flowOptions.openExternal ? false : resolvedTelegramOptions.openLink
+                    });
+                    if (next.status === 'pending') {
+                        if (next.bindUrl && flowOptions.openExternal) {
+                            flowOptions.openExternal(next.bindUrl);
+                        }
+                        openedView = walletViewFromCapability(pendingWalletCapabilityFromState(next), message);
+                    }
+                }
+                if (flowOptions.waitForReady === false) {
+                    return openedView ?? this.refreshWallet();
+                }
+                const timeoutMs = flowOptions.timeoutMs ?? 120000;
+                const pollIntervalMs = flowOptions.pollIntervalMs ?? 1500;
+                const deadline = Date.now() + Math.max(0, timeoutMs);
+                do {
+                    capability = await this.checkWallet();
+                    if (capability.status !== 'pending') {
+                        return walletViewFromCapability(capability, message);
+                    }
+                    if (Date.now() >= deadline) {
+                        return walletViewFromCapability(capability, message);
+                    }
+                    await delay(pollIntervalMs);
+                } while (true);
+            }
+            catch (error) {
+                const normalized = normalizeEosConnectError(error);
+                publish({
+                    ...state,
+                    status: 'error',
+                    error: normalized.message
+                });
+                return walletViewFromError(normalized, message);
+            }
+        },
+        async enableQuickPay(flowOptions = {}) {
+            return quickPayFromView(await this.startTelegramWalletFlow(flowOptions));
+        },
         async connectTokenPocket(tokenPocketOptions = {}) {
             const paymentKey = await generateEosConnectPaymentKey();
             const next = await this.connect({
@@ -1450,7 +1608,7 @@ export function createEosConnect(options) {
             }
             await saveEosConnectPaymentKey(paymentKey.privateKey, telegramWebApp());
             if (tokenPocketOptions.openLink !== false) {
-                openExternalUrl(tokenPocketDappUrl(next.bindUrl), options, telegramWebApp());
+                openExternalUrl(tokenPocketDappUrl(next.bindUrl, options.tokenPocketSource), options, telegramWebApp());
             }
             return next;
         },

package/dist/telegram-web-app.d.ts

@@ -0,0 +1,35 @@
+export interface EosConnectTelegramWebApp {
+    initData?: string;
+    initDataUnsafe?: {
+        user?: {
+            language_code?: string;
+        };
+    };
+    platform?: string;
+    version?: string;
+    openLink?(url: string): void;
+    SecureStorage?: {
+        setItem(key: string, value: string, callback?: (error: string | null, isStored?: boolean) => void): void;
+        getItem(key: string, callback: (error: string | null, value?: string | null) => void): void;
+        removeItem?(key: string, callback?: (error: string | null, isRemoved?: boolean) => void): void;
+    };
+    BiometricManager?: {
+        isInited?: boolean;
+        isBiometricAvailable?: boolean;
+        isAccessRequested?: boolean;
+        isAccessGranted?: boolean;
+        isBiometricTokenSaved?: boolean;
+        init(callback?: () => void): void;
+        requestAccess?(params: {
+            reason?: string;
+        }, callback?: (isGranted: boolean) => void): void;
+        authenticate(params: {
+            reason?: string;
+        }, callback: (isAuthenticated: boolean, biometricToken?: string) => void): void;
+        updateBiometricToken(token: string, callback?: (isUpdated: boolean) => void): void;
+        openSettings?(): void;
+    };
+}
+export declare const EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL = "https://telegram.org/js/telegram-web-app.js";
+export declare function getEosConnectTelegramWebApp(): EosConnectTelegramWebApp | null;
+export declare function loadEosConnectTelegramWebAppSdk(doc?: Document | null | undefined): Promise<void>;

package/dist/telegram-web-app.js

@@ -0,0 +1,37 @@
+export const EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL = 'https://telegram.org/js/telegram-web-app.js';
+let telegramWebAppSdkLoadPromise = null;
+export function getEosConnectTelegramWebApp() {
+    const maybeGlobal = globalThis;
+    return maybeGlobal.window?.Telegram?.WebApp ?? maybeGlobal.Telegram?.WebApp ?? null;
+}
+export function loadEosConnectTelegramWebAppSdk(doc = globalThis.document) {
+    if (getEosConnectTelegramWebApp()) {
+        return Promise.resolve();
+    }
+    if (telegramWebAppSdkLoadPromise) {
+        return telegramWebAppSdkLoadPromise;
+    }
+    if (!doc?.head) {
+        return Promise.reject(new Error('Document is not available to load Telegram WebApp SDK'));
+    }
+    telegramWebAppSdkLoadPromise = new Promise((resolve, reject) => {
+        const finish = () => resolve();
+        const fail = () => {
+            telegramWebAppSdkLoadPromise = null;
+            reject(new Error('Failed to load Telegram WebApp SDK'));
+        };
+        const existing = doc.querySelector(`script[src="${EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL}"]`);
+        if (existing) {
+            existing.addEventListener('load', finish, { once: true });
+            existing.addEventListener('error', fail, { once: true });
+            return;
+        }
+        const script = doc.createElement('script');
+        script.src = EOS_CONNECT_TELEGRAM_WEB_APP_SDK_URL;
+        script.async = true;
+        script.onload = finish;
+        script.onerror = fail;
+        doc.head.appendChild(script);
+    });
+    return telegramWebAppSdkLoadPromise;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eos3/connect",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "description": "Framework-neutral browser SDK for EOS Passkey Connect in Telegram Mini Apps.",
   "type": "module",
   "license": "UNLICENSED",