@talken/talkenkit 2.3.4

package/dist/wallets/walletConnectors/abcWallet/types.d.ts

@@ -0,0 +1,546 @@
+/**
+ * ABC WaaS Type Definitions
+ *
+ * Based on reference implementation:
+ * /Users/minsuj/Claude/tg-wallet-frontend-develop-minsuj/src/features/wallet/api/
+ */
+/**
+ * Branded types for type safety
+ */
+export type PinHash = string & {
+    readonly __brand: 'PinHash';
+};
+export type EncryptedValue = string & {
+    readonly __brand: 'EncryptedValue';
+};
+export type SecureChannelId = string & {
+    readonly __brand: 'SecureChannelId';
+};
+/**
+ * ABC WaaS Configuration
+ */
+export interface AbcWalletConfig {
+    /** ABC WaaS API base URL */
+    waasUrl: string;
+    /** API authentication key */
+    apiKey?: string;
+    /** Encryption plain value for secure channel */
+    plain: string;
+    /** Environment mode */
+    environment: 'development' | 'production';
+    /** Project identifier */
+    projectId?: string;
+}
+/**
+ * Authentication provider types
+ */
+export type AbcAuthProvider = 'email' | 'google' | 'apple' | 'telegram' | 'twitter';
+/**
+ * User authentication state
+ */
+export interface AbcUser {
+    /** Unique user identifier */
+    uid: string;
+    /** User email address */
+    email?: string;
+    /** Authentication provider */
+    provider: AbcAuthProvider;
+    /** Firebase ID token */
+    idToken?: string;
+    /** Display name */
+    displayName?: string;
+    /** Profile photo URL */
+    photoUrl?: string;
+}
+/**
+ * Base wallet interface with common fields across all chains
+ */
+export interface BaseWallet {
+    /** User identifier */
+    uid: string;
+    /** Session/Share identifier (unified field for sid/shareId) */
+    sessionId: string;
+    /** Key identifier */
+    keyId: string;
+    /** Encrypted share for MPC */
+    encryptedShare: string;
+}
+/**
+ * Wallet information from ABC WaaS (EVM)
+ */
+export interface AbcEvmWallet extends BaseWallet {
+    /** Wallet address (EVM) */
+    address: string;
+    /** Current chain ID */
+    chainId: number;
+    /** Session identifier (alias for sessionId, for backward compatibility) */
+    sid: string;
+    /** Wallet ID (required for signing) */
+    wid: string;
+    /** Encrypted MPC key share (required for signing) */
+    pvencstr: string;
+    /** Encrypted device password (required for signing) */
+    encryptDevicePassword: string;
+    /** Wallet type */
+    type: 'evm' | 'solana';
+    /** User email (needed for wallet operations) */
+    email: string;
+    /** Public key (optional, from accounts array) */
+    pubkey?: string;
+}
+/**
+ * @deprecated Use AbcEvmWallet instead. This alias is provided for backward compatibility.
+ */
+export type AbcWallet = AbcEvmWallet;
+/**
+ * Solana wallet information (Ed25519)
+ */
+export interface AbcSolanaWallet extends BaseWallet {
+    /** Share identifier (alias for sessionId, for backward compatibility) */
+    shareId: string;
+    /** Ed25519 public key (hex) */
+    publicKey: string;
+    /** Solana address (base58) */
+    address: string;
+}
+/**
+ * Bitcoin wallet information (ECDSA secp256k1, compressed)
+ */
+export interface AbcBitcoinWallet extends BaseWallet {
+    /** Share identifier (alias for sessionId, for backward compatibility) */
+    shareId: string;
+    /** Compressed public key (hex) - 33 bytes with 0x02 or 0x03 prefix */
+    publicKey: string;
+    /** Bitcoin address (Bech32, P2PKH, P2SH, or Taproot) */
+    address: string;
+    /** Address type */
+    addressType: 'p2pkh' | 'p2sh' | 'bech32' | 'taproot';
+    /** Network */
+    network: 'bitcoin' | 'bitcoin_testnet';
+}
+/**
+ * Bitcoin UTXO (Unspent Transaction Output)
+ */
+export interface BitcoinUtxo {
+    /** Transaction ID */
+    txid: string;
+    /** Output index */
+    vout: number;
+    /** Value in satoshis */
+    value: number;
+    /** Script public key (hex) */
+    scriptPubKey: string;
+    /** Number of confirmations */
+    confirmations: number;
+}
+/**
+ * Complete ABC authentication state
+ */
+export interface AbcAuthState {
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Current user information */
+    user: AbcUser | null;
+    /** EVM wallet information */
+    wallet: AbcEvmWallet | null;
+    /** Solana wallet information */
+    solanaWallet: AbcSolanaWallet | null;
+    /** Bitcoin wallet information */
+    bitcoinWallet: AbcBitcoinWallet | null;
+    /** Access token */
+    accessToken: string | null;
+    /** Refresh token */
+    refreshToken: string | null;
+    /** Token expiration timestamp */
+    expiresAt: number | null;
+    /** User PIN (hashed for security) */
+    pin?: string;
+}
+/**
+ * Login method parameters
+ */
+export interface AbcLoginParams {
+    /** Login provider */
+    provider: AbcAuthProvider;
+    /** Email address (for email login) */
+    email?: string;
+    /** OTP code (for email login) */
+    otpCode?: string;
+    /** OAuth token (for social login) */
+    token?: string;
+    /** Whether request is from iframe */
+    isIframe?: boolean;
+}
+/**
+ * Wallet generation/recovery parameters
+ */
+export interface AbcWalletParams {
+    /** User identifier */
+    uid: string;
+    /** PIN code (hashed with SHA256) */
+    pin: string;
+    /** Target chain ID */
+    chainId: number;
+    /** Network type */
+    network?: 'mainnet' | 'testnet';
+}
+/**
+ * Transaction signing parameters
+ */
+export interface AbcSignParams {
+    /** Chain ID */
+    chainId: number;
+    /** Transaction object */
+    transaction: any;
+    /** Key identifier */
+    keyId: string;
+    /** Encrypted share */
+    encryptedShare: string;
+    /** PIN code */
+    pin: string;
+}
+/**
+ * Solana transaction signing parameters
+ */
+export interface AbcSignSolanaTransactionParams {
+    /** User identifier */
+    uid: string;
+    /** Share identifier */
+    shareId: string;
+    /** Ed25519 public key */
+    publicKey: string;
+    /** Serialized transaction (hex) */
+    message: string;
+    /** PIN code */
+    pin: string;
+}
+/**
+ * Solana message signing parameters
+ */
+export interface AbcSignSolanaMessageParams {
+    /** User identifier */
+    uid: string;
+    /** Share identifier */
+    shareId: string;
+    /** Ed25519 public key */
+    publicKey: string;
+    /** Message to sign (hex) */
+    message: string;
+    /** PIN code */
+    pin: string;
+}
+/**
+ * Solana transaction broadcast parameters
+ */
+export interface AbcSendSolanaTransactionParams {
+    /** Network (mainnet or devnet) */
+    network: string;
+    /** Serialized transaction (hex) */
+    serializedTX: string;
+    /** Signatures array (hex) */
+    signatures: string[];
+}
+/**
+ * Bitcoin transaction signing parameters (PSBT-based)
+ */
+export interface AbcSignBitcoinTransactionParams {
+    /** User identifier */
+    uid: string;
+    /** Share identifier */
+    shareId: string;
+    /** Compressed public key */
+    publicKey: string;
+    /** PSBT (Partially Signed Bitcoin Transaction) in base64 */
+    psbt: string;
+    /** PIN code (hashed) */
+    pin: string;
+    /** Network */
+    network: 'bitcoin' | 'bitcoin_testnet';
+}
+/**
+ * Bitcoin message signing parameters (BIP-322)
+ */
+export interface AbcSignBitcoinMessageParams {
+    /** User identifier */
+    uid: string;
+    /** Share identifier */
+    shareId: string;
+    /** Compressed public key */
+    publicKey: string;
+    /** Message to sign (hex-encoded) */
+    message: string;
+    /** PIN code (hashed) */
+    pin: string;
+    /** Network */
+    network: 'bitcoin' | 'bitcoin_testnet';
+    /** Message signing standard */
+    messageType?: 'bip322' | 'legacy';
+}
+/**
+ * Bitcoin transaction broadcast parameters
+ */
+export interface AbcSendBitcoinTransactionParams {
+    /** Network */
+    network: 'bitcoin' | 'bitcoin_testnet';
+    /** Raw transaction (hex-encoded) */
+    rawTransaction: string;
+    /** Optional: Finalized PSBT */
+    psbt?: string;
+}
+/**
+ * Bitcoin signature response (PSBT with multiple input signatures)
+ */
+export interface AbcBitcoinSignatureResponse {
+    /** Signed PSBT (base64) */
+    signedPsbt: string;
+    /** Individual signatures for each input */
+    signatures: Array<{
+        inputIndex: number;
+        publicKey: string;
+        signature: string;
+        sighashType: number;
+    }>;
+}
+/**
+ * Bitcoin message signature response (BIP-322)
+ */
+export interface AbcBitcoinMessageSignatureResponse {
+    /** Base64-encoded signature */
+    signature: string;
+    /** Message hash (SHA-256) */
+    messageHash: string;
+    /** Signer address */
+    address: string;
+    /** Network */
+    network: 'bitcoin' | 'bitcoin_testnet';
+}
+/**
+ * Message signing parameters
+ * Based on tg-wallet-frontend reference implementation
+ */
+export interface AbcSignMessageParams {
+    /** Message to sign */
+    message: string;
+    /** Signer address */
+    address: string;
+    /** Encrypted PIN (ciphertext) - DEPRECATED: Not needed for message signing */
+    ciphertext?: string;
+    /** Session ID (required by API) */
+    sid: string;
+    /** User ID (required by API) */
+    uid: string;
+    /** Encrypted private key string (required by API) */
+    pvencstr: string;
+    /** Wallet ID (required by API) */
+    wid: string;
+}
+/**
+ * API response wrapper (discriminated union for type safety)
+ */
+export type AbcApiResponse<T = any> = {
+    status: 'success';
+    data?: T;
+    result?: T;
+    message?: {
+        code: number;
+        text: string;
+    };
+} | {
+    status: 'error';
+    error: {
+        code: string;
+        message: string;
+    };
+    message?: {
+        code: number;
+        text: string;
+    };
+};
+/**
+ * Bitcoin sign API response format
+ * Special format used by /wapi/v2/sign/hash endpoint
+ */
+export interface AbcBitcoinSignResponse {
+    /** Signature string (JSON-encoded) */
+    signstr: string;
+    /** Error flag */
+    iserr: boolean;
+    /** Error message */
+    errmsg: string;
+}
+/**
+ * Login response data
+ */
+export interface AbcLoginResponse {
+    uid: string;
+    email?: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}
+/**
+ * SNS (Social) login parameters
+ */
+export interface AbcSnsLoginParams {
+    /** Firebase ID token from OAuth provider */
+    token: string;
+    /** Social login service provider */
+    service: 'google' | 'apple' | 'kakao';
+    /** User email from OAuth token */
+    email: string;
+    /** ABC WaaS audience URL */
+    audience: string;
+    /** Whether request is from iframe */
+    isIframe?: boolean;
+}
+/**
+ * SNS (Social) login response
+ */
+export interface AbcSnsLoginResponse {
+    uid: string;
+    access_token: string;
+    refresh_token: string;
+    email: string;
+    user_type?: 'new' | 'existing';
+}
+/**
+ * Wallet generation response
+ */
+export interface AbcWalletResponse {
+    address: string;
+    keyId: string;
+    encryptedShare: string;
+    uid: string;
+    sid?: string;
+    wid?: string;
+    pvencstr?: string;
+    encryptDevicePassword?: string;
+    pubkey?: string | null;
+}
+/**
+ * Transaction signature response
+ */
+export interface AbcSignatureResponse {
+    signature: string;
+    txHash?: string;
+}
+/**
+ * OTP request response
+ */
+export interface AbcOtpResponse {
+    sent: boolean;
+    expiresIn: number;
+}
+/**
+ * Token refresh response
+ */
+export interface AbcRefreshTokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}
+/**
+ * PIN management
+ */
+export interface AbcPinConfig {
+    /** Hashed PIN (SHA256) */
+    hashedPin: string;
+    /** PIN creation timestamp */
+    createdAt: number;
+    /** Whether PIN is set */
+    isSet: boolean;
+}
+/**
+ * Storage keys for ABC WaaS data
+ */
+export declare enum AbcStorageKey {
+    USER = "user",
+    WALLET = "wallet",
+    SOLANA_WALLET = "solana_wallet",
+    BITCOIN_WALLET = "bitcoin_wallet",
+    ACCESS_TOKEN = "access_token",
+    REFRESH_TOKEN = "refresh_token",
+    EXPIRES_AT = "expires_at",
+    PIN = "pin",
+    AUTH_STATE = "auth_state",
+    ENCRYPTED_TOKENS = "encrypted_tokens",
+    TOKEN_SALT = "token_salt"
+}
+/**
+ * Error codes
+ */
+export declare enum AbcErrorCode {
+    INVALID_CREDENTIALS = "INVALID_CREDENTIALS",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    WALLET_NOT_FOUND = "WALLET_NOT_FOUND",
+    INVALID_PIN = "INVALID_PIN",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    SIGNATURE_FAILED = "SIGNATURE_FAILED",
+    USER_CANCELLED = "USER_CANCELLED",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    ENCRYPTION_FAILED = "ENCRYPTION_FAILED",
+    DECRYPTION_FAILED = "DECRYPTION_FAILED"
+}
+/**
+ * ABC WaaS Error
+ */
+export declare class AbcError extends Error {
+    code: AbcErrorCode;
+    details?: any;
+    constructor(code: AbcErrorCode, message: string, details?: any);
+}
+/**
+ * Chain configuration
+ */
+export interface AbcChainConfig {
+    /** Chain ID */
+    chainId: number;
+    /** Chain name */
+    name: string;
+    /** Network type */
+    network: 'evm' | 'solana' | 'bitcoin';
+    /** RPC URL */
+    rpcUrl?: string;
+    /** Block explorer URL */
+    explorerUrl?: string;
+}
+/**
+ * Connector options
+ */
+export interface AbcConnectorOptions {
+    /** ABC WaaS configuration */
+    config: AbcWalletConfig;
+    /** Supported chains */
+    chains?: AbcChainConfig[];
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Modal state
+ */
+export interface AbcModalState {
+    /** Whether modal is open */
+    isOpen: boolean;
+    /** Current step in auth flow */
+    step: 'select' | 'email' | 'otp' | 'social' | 'pin' | 'loading' | 'error';
+    /** Error message if any */
+    error?: string;
+}
+/**
+ * Event types
+ */
+export type AbcEventType = 'connect' | 'disconnect' | 'accountsChanged' | 'chainChanged' | 'error';
+/**
+ * Event listener callback
+ */
+export type AbcEventListener = (data: any) => void;
+/**
+ * Email check response
+ * Reference: tg-wallet-frontend signup flow
+ */
+export interface AbcEmailCheckResponse {
+    status: string;
+    message?: {
+        code: number;
+    };
+}

package/dist/wallets/walletConnectors/abcWallet/types.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  AbcError,
+  AbcErrorCode,
+  AbcStorageKey
+} from "../chunk-5UEBEMEE.js";
+export {
+  AbcError,
+  AbcErrorCode,
+  AbcStorageKey
+};

package/dist/wallets/walletConnectors/abcWallet/utils.d.ts

@@ -0,0 +1,152 @@
+/**
+ * ABC WaaS Utility Functions
+ */
+import { type AbcAuthState, AbcError, AbcErrorCode, AbcStorageKey } from './types';
+/**
+ * Hash PIN code with SHA256
+ */
+export declare function hashPin(pin: string): Promise<string>;
+/**
+ * Validate PIN format
+ */
+export declare function validatePin(pin: string): boolean;
+/**
+ * Validate email format
+ */
+export declare function validateEmail(email: string): boolean;
+/**
+ * Get storage key with prefix
+ */
+export declare function getStorageKey(key: AbcStorageKey): string;
+/**
+ * Save to local storage
+ */
+export declare function saveToStorage(key: AbcStorageKey, value: any): void;
+/**
+ * Load from local storage
+ * Handles both JSON-stringified and plain string values
+ */
+export declare function loadFromStorage<T>(key: AbcStorageKey): T | null;
+/**
+ * Remove from local storage
+ */
+export declare function removeFromStorage(key: AbcStorageKey): void;
+/**
+ * Clear all ABC WaaS data from storage
+ */
+export declare function clearStorage(): void;
+/**
+ * Check if token is expired
+ */
+export declare function isTokenExpired(expiresAt: number | null): boolean;
+/**
+ * Calculate token expiry timestamp
+ */
+export declare function calculateExpiryTimestamp(expiresIn: number): number;
+/**
+ * Save authentication state to storage
+ */
+export declare function saveAuthState(state: AbcAuthState): void;
+/**
+ * Load authentication state from storage
+ */
+export declare function loadAuthState(): AbcAuthState | null;
+/**
+ * Clear authentication state
+ */
+export declare function clearAuthState(): void;
+/**
+ * Determine chain type from chain ID
+ */
+export declare function getChainType(chainId: number): 'evm' | 'solana' | 'bitcoin';
+/**
+ * Format address for display (truncate middle)
+ */
+export declare function formatAddress(address: string, startLength?: number, endLength?: number): string;
+/**
+ * Create AbcError from API response
+ */
+export declare function createAbcError(code: AbcErrorCode, message: string, details?: any): AbcError;
+/**
+ * Sleep for specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry function with exponential backoff
+ */
+export declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, delay?: number, backoffMultiplier?: number): Promise<T>;
+/**
+ * Parse error from API response
+ * Handles multiple response formats including Bitcoin sign API special format
+ */
+export declare function parseApiError(error: any): AbcError;
+/**
+ * Check if running in browser
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Check if Web3 wallet is installed
+ */
+export declare function isWeb3Available(): boolean;
+/**
+ * Generate random ID
+ */
+export declare function generateId(): string;
+/**
+ * Deep clone object
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Check if object is empty
+ */
+export declare function isEmpty(obj: any): boolean;
+/**
+ * Debounce function
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle function
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Convert hex to number
+ */
+export declare function hexToNumber(hex: string): number;
+/**
+ * Convert number to hex
+ */
+export declare function numberToHex(num: number): string;
+/**
+ * Validate Ethereum address
+ */
+export declare function isValidEthereumAddress(address: string): boolean;
+/**
+ * Validate Solana address
+ */
+export declare function isValidSolanaAddress(address: string): boolean;
+/**
+ * Get explorer URL for transaction
+ */
+export declare function getExplorerUrl(chainId: number, txHash: string): string | null;
+/**
+ * Check if encrypted tokens exist in storage
+ */
+export declare function hasEncryptedTokens(): boolean;
+/**
+ * Save tokens encrypted with PIN
+ * NOTE: pin parameter should be the HASHED PIN (SHA256), not raw PIN
+ */
+export declare function saveEncryptedTokens(accessToken: string, refreshToken: string, expiresIn: number, hashedPin: string): void;
+/**
+ * Load and decrypt tokens with PIN
+ * NOTE: hashedPin parameter should be the HASHED PIN (SHA256), not raw PIN
+ */
+export declare function loadEncryptedTokens(hashedPin: string): {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+} | null;
+/**
+ * Clear encrypted tokens
+ */
+export declare function clearEncryptedTokens(): void;