@talken/talkenkit 2.4.15 → 2.4.17

package/dist/klipWallet-RD5Y4UEK.js

@@ -0,0 +1,8 @@
+"use client";
+import "./chunk-TJX4M23U.js";
+
+// src/wallets/walletConnectors/klipWallet/klipWallet.svg
+var klipWallet_default = 'data:image/svg+xml,<svg width="28" height="28" viewBox="0 0 28 28" fill="none" xmlns="http://www.w3.org/2000/svg">%0A  <rect width="28" height="28" rx="6" fill="%23FEE500"/>%0A  <path d="M8 8H12V20H8V8Z" fill="%233C1E1E"/>%0A  <path d="M14 8L20 14L14 20V8Z" fill="%233C1E1E"/>%0A</svg>%0A';
+export {
+  klipWallet_default as default
+};

package/dist/providers/SignConfirmationProvider/SignConfirmationProvider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Sign Confirmation Provider
+ *
+ * This component:
+ * - Auto-detects ABC Wallet connection
+ * - Registers request interceptor for sign/transaction confirmation
+ * - Shows appropriate confirmation modal based on request type
+ * - Uses RainbowKit theme automatically
+ */
+import React, { type ReactNode } from 'react';
+/**
+ * Hook to check if SignConfirmation modal is enabled.
+ * Returns `true` when `showSignConfirmation={true}` on TalkenKitProvider.
+ */
+export declare function useSignConfirmationEnabled(): boolean;
+export type { SignConfirmationRequest, RequestInterceptor } from './types';
+export type { ResolvedTransactionRequest, ApproveInfo, TransferInfo, SwapInfo, NftApprovalInfo, } from './types';
+interface SignConfirmationProviderProps {
+    children: ReactNode;
+    disabled?: boolean;
+}
+export declare function SignConfirmationProvider({ children, disabled, }: SignConfirmationProviderProps): React.JSX.Element;

package/dist/providers/SignConfirmationProvider/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SignConfirmationProvider Module
+ * Re-exports all public APIs
+ */
+export { SignConfirmationProvider, useSignConfirmationEnabled, } from './SignConfirmationProvider';
+export type { SignConfirmationRequest, RequestInterceptor, ResolvedTransactionRequest, ApproveInfo, TransferInfo, SwapInfo, NftApprovalInfo, RequestType, ParsedSignRequest, ParsedTypedDataRequest, ParsedTransactionParams, } from './types';

package/dist/providers/SignConfirmationProvider/requestParsers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Request Parsing Utilities
+ * Parse and decode various EVM request types for sign confirmation
+ */
+import type { ParsedSignRequest, ParsedTransactionParams, ParsedTypedDataRequest, RequestType } from './types';
+/**
+ * Determine request type from method
+ */
+export declare function getRequestType(method: string): RequestType;
+/**
+ * Parse personal_sign request params
+ * personal_sign: [message, address] - message can be hex or utf8
+ */
+export declare function parsePersonalSignParams(params: unknown[]): ParsedSignRequest;
+/**
+ * Parse eth_signTypedData_v4 request params
+ * eth_signTypedData_v4: [address, typedDataJson]
+ */
+export declare function parseTypedDataParams(params: unknown[]): ParsedTypedDataRequest | null;
+/**
+ * Parse eth_sendTransaction request params
+ * Extracts basic tx fields and decodes function data (sync, pure function)
+ */
+export declare function parseTransactionParams(params: unknown[]): ParsedTransactionParams | null;

package/dist/providers/SignConfirmationProvider/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * SignConfirmationProvider Types
+ * Extracted from SignConfirmationProvider.tsx for better modularity
+ */
+import type { FunctionType } from '../../components/ConfirmationModal/transactionUIRegistry';
+import type { GasOption } from '../../components/GasFeeModal';
+import type { NetworkConfig } from '../../config/networks';
+import type { FungibleToken, NonFungibleToken } from '../../types/token';
+import type { DecodedTransaction } from '../../utils/abi/abiDecoder';
+import type { ABCToken, SuggestedGasFees } from '../../wallets/walletConnectors/abcWallet/types';
+/**
+ * Sign confirmation request data
+ */
+export interface SignConfirmationRequest {
+    method: string;
+    params: unknown[];
+    chainId: number;
+    address: string;
+}
+/**
+ * Request interceptor function type
+ * Returns resolved transaction with user modifications if changed, undefined otherwise
+ */
+export type RequestInterceptor = (request: SignConfirmationRequest) => Promise<ResolvedTransactionRequest | undefined>;
+/**
+ * Request type classification
+ */
+export type RequestType = 'sign' | 'typedData' | 'transaction' | null;
+export interface ParsedSignRequest {
+    message: string;
+}
+export interface ParsedTypedDataRequest {
+    readableMessage: string;
+}
+/** Parsed transaction parameters (sync parsing result) */
+export interface ParsedTransactionParams {
+    to: string | null;
+    value: string;
+    data: string;
+    gasLimit?: string;
+    providedMaxFee?: string;
+    providedPriorityFee?: string;
+    decodedFunction?: DecodedTransaction;
+    functionType?: FunctionType;
+}
+/** ERC20 approve transaction info */
+export interface ApproveInfo {
+    spender: string;
+    amount: bigint;
+    balance?: bigint;
+    token: FungibleToken;
+}
+/** Token/Native transfer info */
+export interface TransferInfo {
+    from: string;
+    to: string;
+    token: FungibleToken | NonFungibleToken;
+    amount: string;
+    amountUsd?: string;
+}
+/** DEX swap transaction info */
+export interface SwapInfo {
+    tokenIn: FungibleToken;
+    tokenOut: FungibleToken;
+    amountIn: bigint;
+    amountOutMin: bigint;
+}
+/** NFT setApprovalForAll transaction info */
+export interface NftApprovalInfo {
+    operator: string;
+    approved: boolean;
+    nft?: NonFungibleToken;
+}
+/** Fully resolved transaction with decoded info and metadata */
+export interface ResolvedTransactionRequest {
+    to: string | null;
+    value: string;
+    data: string;
+    gasLimit?: string;
+    networkConfig?: NetworkConfig;
+    chainIconUrl?: string;
+    suggestedGasFees?: SuggestedGasFees;
+    gasFee?: GasOption;
+    functionType?: FunctionType;
+    decodedFunction?: DecodedTransaction;
+    approveInfo?: ApproveInfo;
+    transferInfo?: TransferInfo;
+    swapInfo?: SwapInfo;
+    nftApprovalInfo?: NftApprovalInfo;
+    nativeCoin?: ABCToken;
+}

package/dist/providers/SignConfirmationProvider/useApiClient.d.ts

@@ -0,0 +1,15 @@
+/**
+ * API Client Hook
+ * Provides API calls for gas fees, token metadata, and NFT metadata
+ */
+import type { ABCNFT, ABCToken, SuggestedGasFees } from '../../wallets/walletConnectors/abcWallet/types';
+/**
+ * Hook providing API client functions for transaction confirmation
+ */
+export declare function useApiClient(): {
+    fetchGasFees: (chainId: number) => Promise<SuggestedGasFees | null>;
+    fetchGasLimit: (chainId: number, to: string, value: string, data: string, fromAddress?: string) => Promise<string | null>;
+    fetchNativeTokenMetadata: (walletAddress: string, chainId: number) => Promise<ABCToken | null>;
+    fetchTokenMetadata: (tokenAddress: string, chainId: number) => Promise<ABCToken | null>;
+    fetchNFTMetadata: (contractAddress: string, walletAddress: string, chainId: number) => Promise<ABCNFT | null>;
+};

package/dist/providers/SignConfirmationProvider/useTransactionResolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transaction Resolver Hook
+ * Resolves transaction parameters including gas estimation, function decoding,
+ * and metadata fetching for different transaction types
+ */
+import type { ParsedTransactionParams, ResolvedTransactionRequest, SignConfirmationRequest } from './types';
+/**
+ * Hook providing transaction resolution functions
+ */
+export declare function useTransactionResolver(): {
+    resolveTransaction: (request: SignConfirmationRequest) => Promise<ResolvedTransactionRequest | null>;
+    resolveGasAndMetadata: (parsed: ParsedTransactionParams, chainId: number, fromAddress?: string) => Promise<ResolvedTransactionRequest | null>;
+    resolveTransferInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveNativeTransferInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => void;
+    resolveApproveInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveSwapInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+    resolveNftApprovalInfo: (parsed: ResolvedTransactionRequest, request: SignConfirmationRequest) => Promise<void>;
+};

package/dist/secure-AEBFSVWE.js

@@ -0,0 +1,8 @@
+"use client";
+import {
+  secure_default
+} from "./chunk-VE53ZNZV.js";
+import "./chunk-TJX4M23U.js";
+export {
+  secure_default as default
+};

package/dist/services/AbcAgenticWalletService.d.ts

@@ -0,0 +1,111 @@
+/**
+ * ABC Agentic Wallet Service
+ *
+ * API-first helper for:
+ * - Email OTP signup/login (Coinbase-like embedded onboarding)
+ * - Wallet bootstrap with ABC MPC
+ * - Talken agent session lifecycle (issue/sign/revoke)
+ */
+import type { AbcApiResponse, AbcLoginResponse, AbcWalletResponse } from '../wallets/walletConnectors/abcWallet/types';
+type RuntimeEnv = 'development' | 'production';
+export interface AgentSessionScope {
+    chains?: number[];
+    methods?: string[];
+    addresses?: string[];
+}
+export interface AgentSessionBudget {
+    amount: string;
+    symbol: string;
+    period: 'hour' | 'day' | 'week' | 'month' | 'lifetime';
+}
+export interface CreateAgentSessionParams {
+    subject: string;
+    ttlSeconds: number;
+    scope?: AgentSessionScope;
+    budget?: AgentSessionBudget;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentSession {
+    sessionId: string;
+    expiresAt: string;
+    scope?: AgentSessionScope;
+    budget?: AgentSessionBudget;
+    status?: 'active' | 'revoked' | 'expired';
+}
+export interface AgentSignRequest {
+    operation: 'signTransaction' | 'signMessage' | 'signTypedData';
+    chainId: number;
+    payload: Record<string, unknown>;
+}
+export interface AgentSignResponse {
+    signature?: string;
+    txHash?: string;
+    raw?: Record<string, unknown>;
+}
+export interface AbcAgenticWalletServiceConfig {
+    waasUrl?: string;
+    apiServer?: string;
+    environment?: RuntimeEnv;
+    plain?: string;
+    agentSessionBasePath?: string;
+    fetchImpl?: typeof fetch;
+}
+export interface EnsureEmailOtpUserParams {
+    email: string;
+    otpCode: string;
+    displayName?: string;
+    refererUid?: string;
+}
+export interface EnsureEmailOtpUserResult {
+    isNewUser: boolean;
+    login: AbcLoginResponse;
+}
+/**
+ * Email-OTP + Agent Session orchestrator using the real ABC MPC integration.
+ */
+export declare class AbcAgenticWalletService {
+    private readonly apiServer;
+    private readonly agentSessionBasePath;
+    private readonly fetchImpl;
+    private readonly client;
+    constructor(config?: AbcAgenticWalletServiceConfig);
+    /**
+     * Coinbase-like onboarding:
+     * 1) if user does not exist -> signup with OTP
+     * 2) login with OTP
+     */
+    ensureEmailOtpUser(params: EnsureEmailOtpUserParams): Promise<EnsureEmailOtpUserResult>;
+    /**
+     * Explicit OTP send endpoint for email onboarding UI/CLI.
+     */
+    sendSignupOtp(email: string): Promise<AbcApiResponse<any>>;
+    /**
+     * Explicit OTP verify endpoint for email onboarding UI/CLI.
+     */
+    verifySignupOtp(email: string, otpCode: string): Promise<AbcApiResponse<any>>;
+    /**
+     * Generate/recover EVM MPC wallet after auth.
+     */
+    bootstrapEvmWallet(params: {
+        uid: string;
+        pin: string;
+        chainId: number;
+        network?: 'mainnet' | 'testnet';
+    }): Promise<AbcWalletResponse>;
+    /**
+     * Talken server session issue.
+     */
+    createAgentSession(accessToken: string, params: CreateAgentSessionParams): Promise<AgentSession>;
+    /**
+     * Request server-side signing with an issued agent session.
+     */
+    signWithAgentSession(accessToken: string, sessionId: string, request: AgentSignRequest): Promise<AgentSignResponse>;
+    /**
+     * Revoke active agent session.
+     */
+    revokeAgentSession(accessToken: string, sessionId: string): Promise<void>;
+    private isExistingUser;
+    private requestAgentApi;
+}
+export declare function createAbcAgenticWalletService(config?: AbcAgenticWalletServiceConfig): AbcAgenticWalletService;
+export {};

package/dist/services/AbcAuthService.d.ts

@@ -35,66 +35,72 @@ export interface LoginParams {
 }
 /**
  * Register new user with email, password, and OTP
- * Endpoint: POST /abc/adduser
- * Use case: Full email + password registration
+ * POST /wallet/auth { action: 'register' }
  */
-export declare function registerUser(params: RegisterUserParams, config?: {
+export declare function registerUser(params: RegisterUserParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Register SNS user with email and OTP only (no password)
- * Endpoint: POST /abc/snsAdduser
- * Use case: Google login or OTP-only registration
+ * POST /wallet/auth { action: 'register' }
  */
-export declare function registerSnsUser(params: RegisterSnsUserParams, config?: {
+export declare function registerSnsUser(params: RegisterSnsUserParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Set/Reset password for existing user
- * Endpoint: POST /abc/initpassword
- * Use case: Password setup for users registered via SNS (Code 619)
+ * POST /wallet/auth { action: 'password.reset' }
  */
-export declare function resetPassword(params: ResetPasswordParams, config?: {
+export declare function resetPassword(params: ResetPasswordParams, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Check if email already exists
- * Endpoint: GET /abc/emailCheck
+ * POST /wallet/auth { action: 'email.check' }
  */
-export declare function emailCheck(email: string, config?: {
+export declare function emailCheck(email: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Send OTP code to email
- * Endpoint: GET /member/mail-service/{email}/sendcode
+ * POST /wallet/auth { action: 'otp.send' }
  */
-export declare function sendOtpCode(email: string, config?: {
+export declare function sendOtpCode(email: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Verify OTP code for signup
- * Endpoint: POST /member/mail-service/{email}/verifycode
+ * POST /wallet/auth { action: 'otp.verify' }
  */
-export declare function verifyOtpCode(email: string, code: string, config?: {
+export declare function verifyOtpCode(email: string, code: string, _config?: {
     waasUrl?: string;
     environment?: string;
 }): Promise<AbcApiResponse<any>>;
 /**
  * Login with email and password
- * Note: This uses Talken API server, requires fetch directly
+ * POST /wallet/auth { action: 'login', method: 'password' }
  */
-export declare function loginWithPassword(params: LoginParams, apiServer?: string): Promise<any>;
+export declare function loginWithPassword(params: LoginParams, _apiServer?: string): Promise<any>;
 /**
  * Google OAuth Login
- * Flow: Firebase popup → ID token → ABC WaaS snsLogin → Access token
- * Reference: tg-wallet-frontend LoginView/index.tsx:212-228
+ * Flow: Firebase popup → ID token → TalkenApiClient SNS login → Access token
  */
-export declare function googleLogin(config?: {
+export declare function googleLogin(_config?: {
+    waasUrl?: string;
+    environment?: string;
+    apiServer?: string;
+}): Promise<AbcSnsLoginResponse | null>;
+export declare function appleLogin(_config?: {
+    waasUrl?: string;
+    environment?: string;
+    apiServer?: string;
+}): Promise<AbcSnsLoginResponse | null>;
+export declare function kakaoLogin(_config?: {
     waasUrl?: string;
     environment?: string;
     apiServer?: string;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './token';
+export * from './solana';
+export * from './utils';

package/dist/types/token.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Base Token interface
+ * Common fields shared by FungibleToken and NonFungibleToken
+ */
+export interface Token {
+    chainId?: number;
+    network?: string;
+    platform?: string;
+    contractAddress?: string;
+    symbol?: string;
+    name?: string;
+    possibleSpam?: boolean;
+    enable?: boolean;
+    favorite?: boolean;
+    isCustom?: boolean;
+    mintAddress?: string;
+    associatedTokenAddress?: string;
+}
+/**
+ * Fungible Token model
+ * Compatible with ABC backend API and multi-chain support (EVM, Solana)
+ */
+export interface FungibleToken extends Token {
+    symbol: string;
+    decimals?: number;
+    icon?: string;
+    balance?: string;
+    usdRate?: number;
+    krwRate?: number;
+    isNative?: boolean;
+    website?: string;
+    description?: string;
+    totalSupply?: string;
+}
+/**
+ * Contract Type enum
+ * Supports ERC (Ethereum), KIP (Klaytn), and SPL (Solana) standards
+ */
+export declare const ContractType: {
+    readonly ERC20: "ERC20";
+    readonly ERC721: "ERC721";
+    readonly ERC1155: "ERC1155";
+    readonly KIP7: "KIP7";
+    readonly KIP17: "KIP17";
+    readonly KIP37: "KIP37";
+    readonly SPLToken: "SPLToken";
+};
+export type ContractType = (typeof ContractType)[keyof typeof ContractType];
+/**
+ * Parse contract type from string value
+ * @param value - Contract type string (e.g., 'ERC-721', 'erc721', 'KIP-7')
+ * @returns ContractType or null if not found
+ */
+export declare function contractTypeNameOf(value: string): ContractType | null;
+/**
+ * NFT Metadata (attributes, traits, etc.)
+ */
+export interface NFTMetadata {
+    attributes?: Array<{
+        trait_type?: string;
+        value?: string | number;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Non-Fungible Token model
+ * Compatible with ABC backend API response (ABCNFT → NonFungibleToken conversion)
+ */
+export interface NonFungibleToken extends Token {
+    contractAddress: string;
+    tokenId: string;
+    contractType?: ContractType;
+    collectionName?: string;
+    description?: string;
+    image?: string;
+    animationUrl?: string;
+    tokenUri?: string;
+    balance?: string;
+    isSbt?: boolean;
+    lastTransferAt?: string;
+    meta?: NFTMetadata;
+}

package/dist/utils/abi/abiDecoder.d.ts

@@ -0,0 +1,144 @@
+/**
+ * ABI Decoder
+ *
+ * Decodes transaction hex data using selector_index.json
+ * TypeScript port from Android ABIDecoder
+ */
+/**
+ * Input parameter definition
+ */
+export interface InputParam {
+    name: string;
+    type: string;
+    components?: InputParam[];
+    internalType?: string;
+}
+/**
+ * Function info from selector index
+ */
+export interface FunctionInfo {
+    name: string;
+    signature: string;
+    inputs: InputParam[];
+    sources: string[];
+}
+/**
+ * Metadata sources info
+ */
+export interface MetadataSources {
+    standards?: {
+        files: number;
+        functions: number;
+    };
+    implementations?: {
+        files: number;
+        functions: number;
+    };
+    sourcify?: {
+        contracts: number;
+        functions: number;
+    };
+    total?: number;
+}
+/**
+ * Selector index metadata
+ */
+export interface Metadata {
+    generatedAt: string;
+    totalFunctions: number;
+    sources?: MetadataSources;
+    collisions?: number;
+}
+/**
+ * Selector index structure
+ */
+export interface SelectorIndex {
+    functions: Record<string, FunctionInfo>;
+    metadata: Metadata;
+}
+/**
+ * Decoded transaction result
+ */
+export interface DecodedTransaction {
+    functionName: string;
+    signature: string;
+    selector: string;
+    parameters: Record<string, unknown>;
+    sources: string[];
+}
+/**
+ * ABI Decoder class
+ * Decodes EVM transaction calldata using a selector index
+ */
+export declare class ABIDecoder {
+    private selectorIndex;
+    constructor(selectorIndexJson: string | SelectorIndex);
+    /**
+     * Get function info by selector
+     */
+    getFunctionInfo(selector: string): FunctionInfo | null;
+    /**
+     * Get all known selectors
+     */
+    getKnownSelectors(): string[];
+    /**
+     * Get metadata
+     */
+    getMetadata(): Metadata;
+    /**
+     * Decode transaction hex data
+     *
+     * @param hexData Transaction input data (starts with 0x)
+     * @returns Decoded transaction information or null if unknown
+     */
+    decode(hexData: string): DecodedTransaction | null;
+    /**
+     * Decode ABI parameters
+     */
+    private decodeParameters;
+    /**
+     * Decode single value from data at given offset
+     */
+    private decodeValue;
+    /**
+     * Convert hex string to byte array
+     */
+    private hexToBytes;
+    /**
+     * Convert byte array to hex string
+     */
+    private bytesToHex;
+    /**
+     * Convert byte array to BigInt (unsigned)
+     */
+    private bytesToBigInt;
+}
+/**
+ * Create ABIDecoder from JSON string or object
+ */
+export declare function createABIDecoder(selectorIndex: string | SelectorIndex): ABIDecoder;
+/**
+ * Default selector index (common ERC20/721/1155 functions)
+ * This is a minimal set; for full coverage, load selector_index.json
+ */
+export declare const DEFAULT_SELECTORS: SelectorIndex;
+/**
+ * Usage example:
+ *
+ * // Using default selectors
+ * const decoder = new ABIDecoder(DEFAULT_SELECTORS);
+ *
+ * // Or load full selector index
+ * import selectorIndex from './selector_index.json';
+ * const fullDecoder = new ABIDecoder(selectorIndex);
+ *
+ * // Decode transaction
+ * const hexData = '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f0bee40000000000000000000000000000000000000000000000000de0b6b3a7640000';
+ * const result = decoder.decode(hexData);
+ *
+ * result?.let {
+ *   console.log('Function:', result.functionName);       // 'transfer'
+ *   console.log('Signature:', result.signature);         // 'transfer(address,uint256)'
+ *   console.log('Parameters:', result.parameters);       // { to: '0x...', amount: '1000000000000000000' }
+ * }
+ */

package/dist/utils/apiClientFactory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * API Client Factory Utilities
+ *
+ * Centralizes ABC WaaS API client creation to avoid code duplication.
+ */
+import { GasApi, WalletscanApi } from '../wallets/walletConnectors/abcWallet/api';
+import type { AbcWalletConfig } from '../wallets/walletConnectors/abcWallet/types';
+/**
+ * Get the ABC API configuration from environment variables
+ */
+export declare function getAbcApiConfig(): AbcWalletConfig;
+/**
+ * Create a WalletscanApi instance
+ * Use this for token metadata, NFT info, and wallet balance queries
+ */
+export declare function createWalletscanApi(): WalletscanApi;
+/**
+ * Create a GasApi instance
+ * Use this for gas fee estimation and suggestions
+ */
+export declare function createGasApi(): GasApi;

package/dist/utils/blockies.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Blockies - Ethereum address identicon generator
+ * Creates a data URL for a blockie image based on address
+ */
+/**
+ * Generate a blockies data URL for an Ethereum address
+ * @param address - Ethereum address (0x...)
+ * @param size - Size of the blockie (default: 8)
+ * @param scale - Scale factor (default: 4)
+ * @returns Data URL string for the blockie image
+ */
+export declare function createBlockiesDataUrl(address: string, size?: number, scale?: number): string;