9c:I[903690,["/chat-static/_next/static/immutable/chunks/3k63mkih5bznc.js","/chat-static/_next/static/immutable/chunks/14-0r501-ib16.js","/chat-static/_next/static/immutable/chunks/2w32a37kj0mcq.js","/chat-static/_next/static/immutable/chunks/0lyxw0nk-7-p_.js","/chat-static/_next/static/immutable/chunks/2836u6jwf9bgv.js","/chat-static/_next/static/immutable/chunks/3ktygcwrvju41.js","/chat-static/_next/static/immutable/chunks/1l25yg7ejc3lm.js","/chat-static/_next/static/immutable/chunks/3xgcz543a20n9.js","/chat-static/_next/static/immutable/chunks/2ks2dvr47nqsg.js","/chat-static/_next/static/immutable/chunks/0wp9iyt7gqj9c.js","/chat-static/_next/static/immutable/chunks/03w_e6mqufrhn.js","/chat-static/_next/static/immutable/chunks/3su8b9kn4mbaa.js","/chat-static/_next/static/immutable/chunks/2sp-yda0t06bm.js","/chat-static/_next/static/immutable/chunks/06-mpaxkl_qww.js","/chat-static/_next/static/immutable/chunks/2v1ytxhjawdqw.js","/chat-static/_next/static/immutable/chunks/3vhx3fg583u19.js","/chat-static/_next/static/immutable/chunks/3bon2sery8l35.js","/chat-static/_next/static/immutable/chunks/022gnoebsh94r.js","/chat-static/_next/static/immutable/chunks/0iy9i8p65rpg9.js","/chat-static/_next/static/immutable/chunks/0dd_lmx4c6nxh.js","/chat-static/_next/static/immutable/chunks/1xg3_d5lvvdxc.js","/chat-static/_next/static/immutable/chunks/00hu8fdgh1j4v.js","/chat-static/_next/static/immutable/chunks/0ggiln07qpg3x.js","/chat-static/_next/static/immutable/chunks/3my68vmtl-_et.js","/chat-static/_next/static/immutable/chunks/362eoze68z3tj.js","/chat-static/_next/static/immutable/chunks/0p46wv3i3degh.js","/chat-static/_next/static/immutable/chunks/2s3rmbgvk5alc.js","/chat-static/_next/static/immutable/chunks/2ihe2cde8-h-m.js","/chat-static/_next/static/immutable/chunks/3zol0rg92lx8j.js","/chat-static/_next/static/immutable/chunks/24oxen36r-7_-.js","/chat-static/_next/static/immutable/chunks/1gzs-9f4hqwiw.js","/chat-static/_next/static/immutable/chunks/2r3778mxx4zx3.js","/chat-static/_next/static/immutable/chunks/2p_u1hp1r7f_k.js","/chat-static/_next/static/immutable/chunks/27kqtemkm6wc0.js","/chat-static/_next/static/immutable/chunks/1gdd26lvq120i.js","/chat-static/_next/static/immutable/chunks/2ctequm16gwee.js","/chat-static/_next/static/immutable/chunks/28nxf7yiyc24v.js","/chat-static/_next/static/immutable/chunks/04a8jfjv6v0qb.js","/chat-static/_next/static/immutable/chunks/42wwo8qnl2vbp.js","/chat-static/_next/static/immutable/chunks/21dsrwe8r8n6i.js","/chat-static/_next/static/immutable/chunks/149z86gjpz-xn.js","/chat-static/_next/static/immutable/chunks/12l6-xc865av_.js","/chat-static/_next/static/immutable/chunks/041ay0fy85meq.js","/chat-static/_next/static/immutable/chunks/037e36pvrsirw.js","/chat-static/_next/static/immutable/chunks/0grfnmr66iua1.js","/chat-static/_next/static/immutable/chunks/2lrp559d1wync.js","/chat-static/_next/static/immutable/chunks/0mn-dmkxxrk86.js","/chat-static/_next/static/immutable/chunks/2rhujd4vukzvn.js","/chat-static/_next/static/immutable/chunks/1nzwnmkih6gs1.js","/chat-static/_next/static/immutable/chunks/01enxheexz0xq.js","/chat-static/_next/static/immutable/chunks/1qayp2hmff121.js","/chat-static/_next/static/immutable/chunks/2k0t6m9hg03ay.js","/chat-static/_next/static/immutable/chunks/408m_6lxo2us-.js"],"ExplicitChatIdProvider"] 9d:I[838238,["/chat-static/_next/static/immutable/chunks/3k63mkih5bznc.js","/chat-static/_next/static/immutable/chunks/14-0r501-ib16.js","/chat-static/_next/static/immutable/chunks/2w32a37kj0mcq.js","/chat-static/_next/static/immutable/chunks/0lyxw0nk-7-p_.js","/chat-static/_next/static/immutable/chunks/2836u6jwf9bgv.js","/chat-static/_next/static/immutable/chunks/3ktygcwrvju41.js","/chat-static/_next/static/immutable/chunks/1l25yg7ejc3lm.js","/chat-static/_next/static/immutable/chunks/3xgcz543a20n9.js","/chat-static/_next/static/immutable/chunks/2ks2dvr47nqsg.js","/chat-static/_next/static/immutable/chunks/0wp9iyt7gqj9c.js","/chat-static/_next/static/immutable/chunks/03w_e6mqufrhn.js","/chat-static/_next/static/immutable/chunks/3su8b9kn4mbaa.js","/chat-static/_next/static/immutable/chunks/2sp-yda0t06bm.js","/chat-static/_next/static/immutable/chunks/06-mpaxkl_qww.js","/chat-static/_next/static/immutable/chunks/2v1ytxhjawdqw.js","/chat-static/_next/static/immutable/chunks/3vhx3fg583u19.js","/chat-static/_next/static/immutable/chunks/3bon2sery8l35.js","/chat-static/_next/static/immutable/chunks/022gnoebsh94r.js","/chat-static/_next/static/immutable/chunks/0iy9i8p65rpg9.js","/chat-static/_next/static/immutable/chunks/0dd_lmx4c6nxh.js","/chat-static/_next/static/immutable/chunks/1xg3_d5lvvdxc.js","/chat-static/_next/static/immutable/chunks/00hu8fdgh1j4v.js","/chat-static/_next/static/immutable/chunks/0ggiln07qpg3x.js","/chat-static/_next/static/immutable/chunks/3my68vmtl-_et.js","/chat-static/_next/static/immutable/chunks/362eoze68z3tj.js","/chat-static/_next/static/immutable/chunks/0p46wv3i3degh.js","/chat-static/_next/static/immutable/chunks/2s3rmbgvk5alc.js","/chat-static/_next/static/immutable/chunks/2ihe2cde8-h-m.js","/chat-static/_next/static/immutable/chunks/3zol0rg92lx8j.js","/chat-static/_next/static/immutable/chunks/24oxen36r-7_-.js","/chat-static/_next/static/immutable/chunks/1gzs-9f4hqwiw.js","/chat-static/_next/static/immutable/chunks/2r3778mxx4zx3.js","/chat-static/_next/static/immutable/chunks/2p_u1hp1r7f_k.js","/chat-static/_next/static/immutable/chunks/27kqtemkm6wc0.js","/chat-static/_next/static/immutable/chunks/1gdd26lvq120i.js","/chat-static/_next/static/immutable/chunks/2ctequm16gwee.js","/chat-static/_next/static/immutable/chunks/28nxf7yiyc24v.js","/chat-static/_next/static/immutable/chunks/04a8jfjv6v0qb.js","/chat-static/_next/static/immutable/chunks/42wwo8qnl2vbp.js","/chat-static/_next/static/immutable/chunks/21dsrwe8r8n6i.js","/chat-static/_next/static/immutable/chunks/149z86gjpz-xn.js","/chat-static/_next/static/immutable/chunks/12l6-xc865av_.js","/chat-static/_next/static/immutable/chunks/041ay0fy85meq.js","/chat-static/_next/static/immutable/chunks/037e36pvrsirw.js","/chat-static/_next/static/immutable/chunks/0grfnmr66iua1.js","/chat-static/_next/static/immutable/chunks/2lrp559d1wync.js","/chat-static/_next/static/immutable/chunks/0mn-dmkxxrk86.js","/chat-static/_next/static/immutable/chunks/2rhujd4vukzvn.js","/chat-static/_next/static/immutable/chunks/1nzwnmkih6gs1.js","/chat-static/_next/static/immutable/chunks/01enxheexz0xq.js","/chat-static/_next/static/immutable/chunks/1qayp2hmff121.js","/chat-static/_next/static/immutable/chunks/2k0t6m9hg03ay.js","/chat-static/_next/static/immutable/chunks/408m_6lxo2us-.js"],"SWRDataProvider"] 9f:[] a0:[["b_grCSYwKyqF2",null],["b_PLvJtUO1WJN",null],["b_cpEa63pu5fE",null],["b_vqPlZxLSCNI",null],["b_nOiCdBAjI3F",null],["b_HH5ythyPPkZ",null],["b_ls4t3WSu9NG",null]] a1:[["b_grCSYwKyqF2",{"templateVersionId":null,"templateCanonId":null}],["b_PLvJtUO1WJN",{"templateVersionId":null,"templateCanonId":null}],["b_cpEa63pu5fE",{"templateVersionId":null,"templateCanonId":null}],["b_vqPlZxLSCNI",{"templateVersionId":null,"templateCanonId":null}],["b_nOiCdBAjI3F",{"templateVersionId":null,"templateCanonId":null}],["b_HH5ythyPPkZ",{"templateVersionId":null,"templateCanonId":null}],["b_ls4t3WSu9NG",{"templateVersionId":null,"templateCanonId":null}]] a2:[["b_MFkRrfVUSFC","$D2025-10-30T00:27:54.110Z"],["b_6Z2WuYEm0P3","$D2025-10-30T01:53:18.127Z"],["b_Z6SQAovEkvb","$D2025-10-30T02:15:25.851Z"],["b_HLnLTQowmKe","$D2025-10-30T02:17:23.850Z"],["b_gegkjzDsLSX","$D2025-10-30T02:22:32.783Z"],["b_QTK9yFd2D2P","$D2025-10-30T02:29:35.459Z"],["b_vaEvHAn2QQL","$D2025-10-30T02:31:44.422Z"],["b_NIv5YlkTcJ3","$D2025-10-30T02:35:07.388Z"],["b_e0Lw0EruLcc","$D2025-10-30T02:45:06.155Z"],["b_f8CImzc4Hn2","$D2025-10-30T02:59:00.031Z"],["b_ghEXO3lnyY8","$D2025-10-30T03:05:39.387Z"],["b_o85hibaJvNx","$D2025-10-30T03:13:19.175Z"],["b_RZRVoMv7g0j","$D2025-10-30T03:34:00.454Z"],["b_s3qiojcp0RS","$D2025-10-30T13:32:17.129Z"],["b_e0ZWQpExRGd","$D2025-10-30T13:33:39.786Z"],["b_rq8uGEgTVjA","$D2025-10-30T13:54:13.195Z"],["b_8DkNYHZmoMx","$D2025-10-31T12:21:49.691Z"],["b_bwD2sD8zgqH","$D2025-11-01T19:32:47.630Z"],["b_F6xjjWt3y2J","$D2025-11-01T23:46:48.436Z"],["b_8AlCWGNUJxP","$D2025-11-02T13:35:03.463Z"],["b_IVuAT8kAK0n","$D2025-11-02T13:36:14.331Z"],["b_WKGowwjtwnj","$D2025-11-02T15:11:46.267Z"],["b_l7K3NMNl6kJ","$D2025-11-02T15:26:00.495Z"],["b_v3unTmrAqZw","$D2025-11-02T15:45:30.294Z"],["b_qjtY35zxNsp","$D2025-11-02T15:47:11.376Z"],["b_M5fJwUgQH7e","$D2025-11-02T15:51:34.289Z"],["b_rix9CaU95mX","$D2025-11-02T15:53:00.502Z"],["b_YRTSbMUXICB","$D2025-11-02T15:55:34.668Z"],["b_bEcZESF5ZMg","$D2025-11-02T16:05:00.550Z"],["b_iiTSIN4RVkw","$D2025-11-02T17:06:10.545Z"],["b_Kae5sKmnDlL","$D2025-11-03T22:24:14.513Z"],["b_hMwXUxB34Kp","$D2025-11-03T22:29:54.863Z"],["b_nsr6uOAHX36","$D2025-11-03T22:33:54.026Z"],["b_C6z2rm0eGHf","$D2025-11-03T22:38:05.316Z"],["b_oxfO2HYSqgK","$D2025-11-04T04:25:30.432Z"],["b_XKUBZxPatpn","$D2025-11-04T04:30:49.935Z"],["b_TWurFGPFOY6","$D2025-11-04T04:37:46.553Z"],["b_N61RWPLjgfy","$D2025-11-04T04:42:56.962Z"],["b_kOXbPbv8hvc","$D2025-11-04T14:01:02.463Z"],["b_5szTAnVrMXR","$D2025-11-04T14:08:23.607Z"],["b_hiZpa0QOQTm","$D2025-11-04T14:12:18.956Z"],["b_5Ej9ObhF7PW","$D2025-11-04T17:57:39.750Z"],["b_L8HGHbLRhqq","$D2025-11-05T14:11:41.803Z"],["b_CaZLP6bQzOG","$D2025-11-05T14:14:23.998Z"],["b_KFxGTic4MFo","$D2025-11-05T14:17:47.423Z"],["b_an4Nim9ntti","$D2025-11-05T14:22:48.481Z"],["b_SC9rgqQfBHj","$D2025-11-05T14:59:39.601Z"],["b_Y9d2ADcmGzK","$D2025-11-05T15:04:11.448Z"],["b_X8qVyQUe8Az","$D2025-11-05T15:08:01.099Z"],["b_rYKXcND3pnX","$D2025-11-06T02:49:32.870Z"],["b_ms1JQoeEYyJ","$D2025-11-06T02:53:53.648Z"],["b_EXxBqtMVcC5","$D2025-11-06T03:06:52.980Z"],["b_Xp6H5bGOiA0","$D2025-11-06T03:07:11.053Z"],["b_btolLYOMxSH","$D2025-11-06T03:09:21.139Z"],["b_VQGziMnRa8c","$D2025-11-06T03:10:24.438Z"],["b_7ayYsANrWq1","$D2025-11-06T03:14:42.005Z"],["b_YHLDPcsadhL","$D2025-11-07T15:26:03.570Z"],["b_Ic1ZV9orSA2","$D2025-11-07T18:45:50.413Z"],["b_TYyMfchA63y","$D2025-11-07T21:21:56.641Z"],["b_wSpH8fRrUYa","$D2025-11-07T21:22:55.156Z"],["b_l1ouQdLeKvT","$D2025-11-07T21:24:08.698Z"],["b_mOHJJr2DAXy","$D2025-11-07T21:25:19.321Z"],["b_Lbq3EQaKFiM","$D2025-11-07T21:36:25.808Z"],["b_lmI9mySfSEF","$D2025-11-08T03:07:17.700Z"],["b_0eI4kn0KUtk","$D2025-11-08T03:10:29.042Z"],["b_85DmLwylhMy","$D2025-11-08T03:14:14.558Z"],["b_OLvX0PEK1aL","$D2025-11-08T03:18:48.722Z"],["b_9GdExVw1z12","$D2025-11-08T04:23:59.759Z"],["b_AXYXoF9f7Fq","$D2025-11-08T04:28:03.819Z"],["b_MMoPMURGuvN","$D2025-11-08T04:30:55.678Z"],["b_I3ebsCuXBCE","$D2025-11-08T04:33:56.800Z"],["b_7ftMx9mnixk","$D2025-11-08T04:38:24.393Z"],["b_KvO3SO8SGR4","$D2025-11-09T01:37:13.614Z"],["b_qhLe6ccWfAC","$D2025-11-09T03:01:02.177Z"],["b_rTGgBeVNMQ0","$D2025-11-09T03:01:45.607Z"],["b_WKsAEmk4dEC","$D2025-11-09T03:02:43.611Z"],["b_fEPWLfjWnrO","$D2025-11-09T03:03:47.800Z"],["b_NvXfyLeVzaH","$D2025-11-09T03:04:05.024Z"],["b_UpJa4Do8qAT","$D2025-11-09T03:06:04.052Z"],["b_N2HimEuYHey","$D2025-11-09T03:11:05.698Z"],["b_bFjhoeh7Rwe","$D2025-11-09T03:16:56.572Z"],["b_T7Az86CyLEC","$D2025-11-10T01:04:08.483Z"],["b_RyI87uFNdfA","$D2025-11-10T01:10:52.374Z"],["b_bIrIljMKxVB","$D2025-11-10T01:15:37.122Z"],["b_hX3hyWdf79z","$D2025-11-10T01:31:21.172Z"],["b_DKMQezD82wv","$D2025-11-10T01:52:11.440Z"],["b_dzvzLgkIJTL","$D2025-11-10T01:52:53.216Z"],["b_3GXiDYPQM4N","$D2025-11-10T01:55:43.162Z"],["b_PjrQiynaG4g","$D2025-11-10T02:06:07.498Z"],["b_A9XuQGsap5g","$D2025-11-10T02:06:43.814Z"],["b_SpLw6UYFmBD","$D2025-11-10T14:12:22.979Z"],["b_48BMq9sl5wI","$D2025-11-10T14:17:59.524Z"],["b_dEGhYHg3d2V","$D2025-11-10T14:21:17.219Z"],["b_8IuIReouaZi","$D2025-11-10T14:26:12.300Z"],["b_d1rmwhbP65o","$D2025-11-10T14:29:41.396Z"],["b_oCykee2l1M1","$D2025-11-10T14:36:38.452Z"],["b_HxHCKmGwkFF","$D2025-11-10T14:58:00.748Z"],["b_NezU741ejno","$D2025-11-10T14:58:12.013Z"],["b_0oJumTlqYDe","$D2025-11-10T15:11:00.056Z"],["b_KtbPplq26VJ","$D2025-11-10T15:18:38.519Z"],["b_GsTYaCRVDmA","$D2025-11-10T16:41:21.853Z"],["b_NvuDNRctiXk","$D2025-11-10T16:50:57.278Z"],["b_lnkHziKGtLD","$D2025-11-10T16:55:17.320Z"],["b_54w0pzsnF5T","$D2025-11-10T16:57:48.047Z"],["b_75TwDgafJXC","$D2025-11-10T20:20:03.858Z"],["b_UH1cwyoN8d6","$D2025-11-10T20:20:50.434Z"],["b_Mp1E74FA9p3","$D2025-11-11T04:59:36.907Z"],["b_H0OWUOk96mP","$D2025-11-11T15:03:59.094Z"],["b_hoIrtrQWYzq","$D2025-11-11T15:12:41.184Z"],["b_c7K4bXeiObs","$D2025-11-12T13:02:16.547Z"],["b_6U4G1yikkiB","$D2025-11-12T13:05:46.614Z"],["b_ekgt7QzONHh","$D2025-11-12T13:06:40.201Z"],["b_aNrmY32yTCJ","$D2025-11-12T13:06:52.110Z"],["b_4A6NIuWx7ve","$D2025-11-12T13:10:46.377Z"],["b_3mwqEUBo6v8","$D2025-11-12T13:11:44.584Z"],["b_rdqQ9zYtuy2","$D2025-11-12T13:14:12.930Z"],["b_PTy3tG1TmC6","$D2025-11-12T13:18:45.742Z"],["b_P8WmV0swMfo","$D2025-11-12T13:21:54.058Z"],["b_mtLuADufwj3","$D2025-11-12T13:22:42.790Z"],["b_sfgzRuqtnVV","$D2025-11-12T13:56:37.481Z"],["b_yo1kOLjnxVx","$D2025-11-12T14:03:08.598Z"],["b_NzRV4g23Yoq","$D2025-11-12T14:03:24.698Z"],["b_0I0nYGDN9Tk","$D2025-11-12T14:09:18.894Z"],["b_szYnvvg16AU","$D2025-11-12T14:09:39.647Z"],["b_22wmsMoqzGZ","$D2025-11-12T14:16:29.790Z"],["b_E1U2rocl0NR","$D2025-11-12T14:17:19.815Z"],["b_wMBJjLgqRNt","$D2025-11-12T14:26:45.757Z"],["b_u14gUtG83Em","$D2025-11-12T14:33:50.219Z"],["b_EsXSwwaQejX","$D2025-11-12T14:40:51.625Z"],["b_sSSg5gEAkGQ","$D2025-11-12T15:18:37.571Z"],["b_7dxaUV9tOnW","$D2025-11-12T15:27:22.590Z"],["b_b4EXPORLt2H","$D2025-11-12T22:09:29.792Z"],["b_UV7EJWqgjIq","$D2025-11-12T22:16:51.693Z"],["b_Si9fYVljdbk","$D2025-11-12T22:18:00.020Z"],["b_cFjSiQyo5gN","$D2025-11-14T13:48:15.760Z"],["b_WoNGCSaaeJS","$D2025-11-16T14:47:12.957Z"],["b_VY7SCYrFx4B","$D2025-11-16T15:22:27.812Z"],["b_tCtssUSONY8","$D2025-11-16T15:23:13.517Z"],["b_hIqqYgYIOgt","$D2025-11-17T23:40:46.061Z"],["b_Hb6juPWscfI","$D2025-11-17T23:42:26.468Z"],["b_y5UGQoYKkD8","$D2025-11-17T23:46:03.265Z"],["b_08ffVXDxj0Z","$D2025-11-17T23:53:17.561Z"],["b_hVdtWCJbLkD","$D2025-11-17T23:59:25.472Z"],["b_yjaq2jpnvqX","$D2025-11-18T00:01:24.849Z"],["b_W413Hj3xmTH","$D2025-11-18T00:06:37.458Z"],["b_46aNkOUbCYz","$D2025-11-18T00:15:57.932Z"],["b_Mg5PshQQa4n","$D2025-11-18T00:27:09.687Z"],["b_mTtB3KNL5ej","$D2025-11-18T00:33:01.697Z"],["b_5whEoC9K3mN","$D2025-11-18T00:38:11.902Z"],["b_T7RxEY8isfV","$D2025-11-18T00:44:44.904Z"],["b_fQjzXu0L28k","$D2025-11-19T01:47:45.167Z"],["b_nRPUtDCwvrU","$D2025-11-19T01:54:23.912Z"],["b_QY2HwN7JFvl","$D2025-11-19T01:55:11.405Z"],["b_QSgwFyrp2GI","$D2025-11-20T02:26:56.897Z"],["b_N3CwuWLo5bz","$D2025-11-20T03:01:38.462Z"],["b_yyImud0dKS0","$D2025-11-20T03:25:21.101Z"],["b_xBT1ip6bF6L","$D2025-11-20T14:53:40.771Z"],["b_q42OlTFmA1F","$D2025-11-21T05:11:29.890Z"],["b_uV1K9Oeaiom","$D2025-11-21T14:43:22.859Z"],["b_zOqS7jJMYz3","$D2025-11-22T16:24:20.580Z"],["b_8sa5rdWe1cp","$D2025-11-22T17:21:03.978Z"],["b_UTHwWp82DcE","$D2025-11-22T17:37:42.900Z"],["b_fkXAWQ814pg","$D2025-11-22T21:52:41.858Z"],["b_wY2NSzgA7D1","$D2025-11-22T21:53:37.086Z"],["b_UJkshwcYicJ","$D2025-11-22T21:54:09.359Z"],["b_iTJqwXI46Hl","$D2025-11-22T22:25:35.289Z"],["b_dsTs6qv5jku","$D2025-11-22T22:36:55.022Z"],["b_wJdL5xxSb9c","$D2025-11-22T22:38:14.858Z"],["b_kdNGyxLgwCb","$D2025-11-22T22:47:09.005Z"],["b_4telUuNMzPL","$D2025-11-22T22:47:38.456Z"],["b_q63FztObm22","$D2025-11-22T22:48:04.755Z"],["b_FmCtj4tXAV9","$D2025-11-22T22:59:02.580Z"],["b_kPi2qcXBZiR","$D2025-11-22T23:08:19.309Z"],["b_xx2wNXAsbEs","$D2025-11-22T23:12:59.225Z"],["b_6FtyDB65tn1","$D2025-11-22T23:20:37.186Z"],["b_hBA4kHV5NdU","$D2025-11-22T23:27:39.433Z"],["b_l6PZsU6c6WI","$D2025-11-22T23:48:04.544Z"],["b_cBbpWU6Hzlo","$D2025-11-23T00:47:28.996Z"],["b_ibZZrnhPTxS","$D2025-11-23T00:53:00.640Z"],["b_RP1mPowsS9h","$D2025-11-23T00:57:16.749Z"],["b_GKAAA4f6V29","$D2025-11-23T01:18:02.898Z"],["b_TGniKlgZxtU","$D2025-11-23T01:23:05.681Z"],["b_IT5U9RJnz4w","$D2025-11-23T01:28:46.263Z"],["b_xonfTmPDhOq","$D2025-11-23T02:34:33.174Z"],["b_8qhv0HgZWo9","$D2025-11-23T02:41:28.081Z"],["b_r5ZSUVdUfLp","$D2025-11-23T03:19:54.287Z"],["b_D55HmwzgkRV","$D2025-11-23T03:25:07.468Z"],["b_uGeCuNads8r","$D2025-11-23T21:40:07.771Z"],["b_HYmeS4LyPxO","$D2025-11-23T21:41:09.662Z"],["b_mXW7rBYayqq","$D2025-11-23T21:42:02.954Z"],["b_34PqBD81lkI","$D2025-11-27T05:08:03.505Z"],["b_N1eOvAhmFjC","$D2025-11-27T05:08:42.967Z"],["b_WPgP15ixW5P","$D2025-11-27T05:47:19.075Z"],["b_Mlpqh9aKqG0","$D2025-11-27T05:50:24.938Z"],["b_pX9jbvN38CD","$D2025-11-27T05:55:42.785Z"],["b_wdbau5RQujV","$D2025-11-27T05:59:49.024Z"],["b_ORdwCAoE1fa","$D2025-11-27T06:07:45.661Z"],["b_dsF4eCRyFlZ","$D2025-11-28T19:16:01.933Z"],["b_sPyxeQHZf60","$D2025-11-28T22:04:29.714Z"],["b_dcYu0FqCxRn","$D2025-11-28T22:16:27.406Z"],["b_FQ0IshRRXQ6","$D2025-11-29T17:03:53.967Z"],["b_6lcGqpQELMv","$D2025-11-29T17:09:49.167Z"],["b_TaPTNAP9RXh","$D2025-11-29T23:26:40.046Z"],["b_1FbiIlCf9En","$D2025-11-29T23:28:35.736Z"],["b_pYJ6woRCQml","$D2025-11-29T23:32:51.275Z"],["b_JBKXgLCQNcA","$D2025-11-29T23:33:13.606Z"],["b_I95EvhxnXAg","$D2025-11-29T23:53:43.098Z"],["b_HHCu0SvHIkn","$D2025-11-29T23:54:57.236Z"],["b_UCBody1QQ8U","$D2025-11-30T00:08:59.337Z"],["b_SCRnSS68h8O","$D2025-11-30T00:10:27.170Z"],["b_bxkbfPsjfMQ","$D2025-12-03T15:23:42.098Z"],["b_sIwc1NdDiMh","$D2025-12-03T15:23:46.207Z"],["b_yBUV6V5PeuO","$D2025-12-03T15:25:21.015Z"],["b_EBN6Xe9Zvrv","$D2025-12-03T15:25:45.698Z"],["b_oOBV9DYtAeW","$D2025-12-03T15:26:07.333Z"],["b_j1Ko0NdZ84R","$D2025-12-03T15:26:20.872Z"],["b_136dhylVdKc","$D2025-12-03T15:26:33.817Z"],["b_Kp31txylS67","$D2025-12-03T15:26:47.365Z"],["b_W53TbA3Y2VI","$D2025-12-03T15:26:59.843Z"],["b_CsB5nadMoDY","$D2025-12-03T15:29:58.186Z"],["b_rKihTBxnAJE","$D2025-12-03T16:27:21.382Z"],["b_D1DSJYN3CkC","$D2025-12-07T16:47:39.824Z"],["b_x458w3HxDWP","$D2025-12-07T18:46:35.122Z"],["b_XknEuvAWHMU","$D2025-12-07T18:48:19.894Z"],["b_8eXifFJNt6B","$D2025-12-08T20:24:03.002Z"],["b_o0amhS0kk5Q","$D2025-12-10T16:34:36.478Z"],["b_MzUS7Mkf4QJ","$D2025-12-10T16:45:23.749Z"],["b_u99hC7ctqpQ","$D2025-12-10T16:46:31.895Z"],["b_gQmSdpv9xRV","$D2025-12-10T16:52:41.493Z"],["b_IsxyVSycXGU","$D2025-12-10T16:58:30.309Z"],["b_2GD61fvxl6p","$D2025-12-10T17:04:04.182Z"],["b_gs6oRt6QxTh","$D2025-12-10T17:09:13.692Z"],["b_UbNKdgRtfFs","$D2025-12-11T14:54:32.016Z"],["b_sUOANC8t78h","$D2025-12-11T15:02:53.347Z"],["b_ejw3Ifdbh5d","$D2025-12-11T15:03:57.514Z"],["b_0rizpeiFpm9","$D2025-12-11T15:13:04.517Z"],["b_f7xPLdBVuyG","$D2025-12-11T15:18:13.074Z"],["b_yoAH54xe2q7","$D2025-12-11T15:19:21.375Z"],["b_vHTe492HbEA","$D2025-12-11T15:24:44.196Z"],["b_mKcSDatnRc1","$D2025-12-12T00:34:27.046Z"],["b_Vd5tEQeQItD","$D2025-12-12T00:35:32.080Z"],["b_lA2dSi4UB15","$D2025-12-12T00:45:28.209Z"],["b_XnTyAbZGXVa","$D2025-12-12T15:29:32.071Z"],["b_7f2V6F7Nx4f","$D2025-12-12T15:34:33.199Z"],["b_6rGdIcuKBK9","$D2025-12-14T05:01:17.802Z"],["b_QO2eyZNfssw","$D2025-12-14T14:01:58.413Z"],["b_wdNOI3ES5iH","$D2025-12-14T14:02:50.270Z"],["b_UFdfn4Y8IEW","$D2025-12-14T14:08:45.598Z"],["b_IolBWq8IdKj","$D2025-12-14T14:19:24.579Z"],["b_9TeQ0cxqEIc","$D2025-12-18T14:47:45.483Z"],["b_1CyUgs3nbIY","$D2025-12-18T14:50:40.118Z"],["b_MnMMxRt7AjO","$D2025-12-19T19:49:52.774Z"],["b_gncJ6jteO2r","$D2025-12-19T19:55:19.216Z"],["b_bHPWWo8XYEW","$D2025-12-20T00:22:13.705Z"],["b_HbBxZibT8Q8","$D2025-12-20T00:23:31.539Z"],["b_uGS4gxBCyM3","$D2025-12-20T02:18:41.534Z"],["b_9546us6iDQP","$D2025-12-20T13:08:13.383Z"],["b_jxhS28AbBx1","$D2025-12-20T13:15:35.706Z"],["b_e63sc5XVAFt","$D2025-12-20T13:29:36.220Z"],["b_cvhiJ21oT9y","$D2025-12-20T13:35:33.151Z"],["b_85INV8QKXXh","$D2025-12-20T13:44:17.123Z"],["b_8LpoeC8Gevk","$D2025-12-20T13:53:53.532Z"],["b_IggyekuPF7K","$D2025-12-20T13:54:44.386Z"],["b_eYXfqBiLH70","$D2025-12-20T14:00:17.742Z"],["b_I4mbstYWi1j","$D2025-12-20T14:01:28.005Z"],["b_mcgvr6p4yL4","$D2025-12-20T14:12:18.745Z"],["b_z8BtlcuWRNE","$D2025-12-20T14:13:33.513Z"],["b_6Y6E3Bf2KCP","$D2025-12-20T14:13:58.641Z"],["b_LXqJ4PVpKFB","$D2025-12-20T14:18:44.643Z"],["b_2zK1Gt6ltIe","$D2025-12-20T14:36:28.511Z"],["b_wSn0Yixi8Cp","$D2025-12-20T14:37:33.918Z"],["b_8uoEnd36PZM","$D2025-12-20T14:38:58.511Z"],["b_u4v6BCF5Bnd","$D2025-12-20T14:49:01.311Z"],["b_YOtDG3iWGU7","$D2025-12-20T15:00:33.234Z"],["b_jHq7cWxiYFA","$D2025-12-20T15:07:29.429Z"],["b_FbfcqU4K5Dx","$D2025-12-20T15:07:57.904Z"],["b_WlRACsXaCfa","$D2025-12-20T15:20:54.266Z"],["b_qm7JurcqTed","$D2025-12-20T15:40:00.372Z"],["b_JheG0byR4nD","$D2025-12-20T15:40:33.090Z"],["b_PY119bDBc9y","$D2025-12-20T15:44:18.737Z"],["b_bT8dPtLn390","$D2025-12-20T15:52:50.320Z"],["b_iYMcb6thoVs","$D2025-12-20T15:59:58.716Z"],["b_1DJcj0KmkBi","$D2025-12-20T16:00:50.841Z"],["b_OQvCA9tgPBI","$D2025-12-20T17:41:24.925Z"],["b_3pyP03LAl0g","$D2025-12-20T23:02:30.493Z"],["b_OFUMOf602tY","$D2025-12-20T23:03:06.100Z"],["b_JgbDU2ZFGyf","$D2025-12-21T03:58:00.649Z"],["b_oIWcZC5h4mm","$D2025-12-21T03:59:06.590Z"],["b_PoSwVuuyPdX","$D2025-12-21T13:56:08.991Z"],["b_vWdbJ92NCbc","$D2025-12-21T13:56:51.909Z"],["b_cqflctGYOIS","$D2025-12-21T14:12:53.550Z"],["b_BBZ5Qsh9NnR","$D2025-12-21T14:13:27.179Z"],["b_dUNZYzGUfcj","$D2025-12-21T14:16:32.662Z"],["b_ORIz83m9GAg","$D2025-12-21T14:21:42.284Z"],["b_JhTLkG8mD24","$D2025-12-21T14:25:39.349Z"],["b_FCIJrXtiWMO","$D2025-12-21T14:26:00.560Z"],["b_lZzl3Gt9hJ8","$D2025-12-21T14:34:43.188Z"],["b_G3zlb4qA6NR","$D2025-12-21T14:40:16.834Z"],["b_f735iDrLEkN","$D2025-12-21T14:40:48.336Z"],["b_JAp373jAdbx","$D2025-12-21T14:42:57.446Z"],["b_PCtamqRtwgS","$D2025-12-21T14:44:16.540Z"],["b_SQ9JLkbiJZq","$D2025-12-21T15:16:39.674Z"],["b_XOn25AkwmKn","$D2025-12-21T15:38:46.153Z"],["b_UzGVZo0PFei","$D2025-12-21T15:39:25.736Z"],["b_MvBOQzxdfIi","$D2025-12-21T16:07:14.712Z"],["b_F4FBsz4acIW","$D2025-12-22T03:06:49.813Z"],["b_ASOW3blHtcY","$D2025-12-22T03:41:36.475Z"],["b_deQBK9xRXN4","$D2025-12-22T03:42:12.570Z"],["b_gtVINcmQw0b","$D2025-12-22T03:44:27.100Z"],["b_5OXMAIXs3Bg","$D2025-12-23T00:06:48.558Z"],["b_Df36jqqfe4s","$D2025-12-23T00:09:04.049Z"],["b_YjZCoIsxNZT","$D2025-12-23T00:24:22.696Z"],["b_KEBYh7dXCZ8","$D2025-12-23T00:30:34.465Z"],["b_BcRgjC4s2o5","$D2025-12-23T00:31:00.222Z"],["b_bfjeVG4Q5L4","$D2025-12-24T00:55:35.618Z"],["b_HTPMD7Tjzu5","$D2025-12-24T01:35:52.010Z"],["b_4pAmUkjZbfy","$D2025-12-24T01:40:40.270Z"],["b_hn7VXpLS5no","$D2025-12-24T01:52:43.081Z"],["b_JYJblSBdQN2","$D2025-12-24T01:52:58.816Z"],["b_vSNEoDgMB4d","$D2025-12-24T02:03:31.829Z"],["b_yHSclta1eAb","$D2025-12-24T02:09:03.986Z"],["b_p3lPt45PFVe","$D2025-12-24T02:14:27.522Z"],["b_5zBT027tY4a","$D2025-12-24T03:30:49.991Z"],["b_aD5g8FDOt64","$D2025-12-24T03:40:41.249Z"],["b_OwIpQP7L62s","$D2025-12-24T03:47:50.402Z"],["b_lUfw76kABwT","$D2025-12-24T04:31:08.098Z"],["b_ofiiqyDDq7H","$D2025-12-24T04:31:56.019Z"],["b_4VpSY94DhqQ","$D2025-12-24T04:37:53.644Z"],["b_GZCgzAMpLyc","$D2025-12-24T04:41:45.749Z"],["b_8d7OM2pmW3x","$D2025-12-24T04:42:02.051Z"],["b_OHSjLYuXFwZ","$D2025-12-24T04:52:37.245Z"],["b_8xd3qno3xQN","$D2025-12-24T05:34:50.275Z"],["b_Q3FnUg2S1gB","$D2025-12-25T14:33:51.152Z"],["b_ThasEOiNpkV","$D2025-12-25T14:36:22.955Z"],["b_2Dl84cxYH3Z","$D2025-12-25T14:40:42.410Z"],["b_hJRGInpQ4up","$D2025-12-25T14:44:37.937Z"],["b_PjgmUNabwHf","$D2025-12-25T14:48:40.930Z"],["b_6FqDW2g8Ttd","$D2025-12-25T15:07:16.466Z"],["b_pIAcTIOWKVT","$D2025-12-26T00:55:04.842Z"],["b_ZzAovJpH5RV","$D2025-12-26T01:05:33.200Z"],["b_BvYeT2Ma4TF","$D2025-12-27T00:23:24.463Z"],["b_QuTwrUSgFfx","$D2025-12-27T00:23:43.253Z"],["b_sMtgYbO7Xu7","$D2025-12-27T00:26:34.916Z"],["b_P7n78kL4XYK","$D2025-12-27T00:26:55.652Z"],["b_H4aGZEvhoOl","$D2025-12-27T00:36:41.900Z"],["b_frfx8BLF3GF","$D2025-12-27T00:41:04.522Z"],["b_rn5ZXtJ69R4","$D2025-12-27T00:48:16.772Z"],["b_QYiXzAwNj0c","$D2025-12-28T01:13:54.611Z"],["b_EYRpRSI8mWV","$D2025-12-28T01:20:04.517Z"],["b_v9oawuOgbRC","$D2025-12-28T01:20:32.539Z"],["b_JnIBYoXnmrn","$D2025-12-28T03:54:01.187Z"],["b_Ly7vKCwWFrj","$D2025-12-29T17:32:32.315Z"],["b_Ln54ncmjtXj","$D2025-12-29T17:34:26.164Z"],["b_asSItfayTWK","$D2025-12-29T17:44:23.454Z"],["b_IkAiXyqkKMw","$D2025-12-29T18:25:02.897Z"],["b_n4UlS2Ka1D2","$D2025-12-29T18:25:30.226Z"],["b_QbvVvWnVr0j","$D2025-12-29T18:30:37.464Z"],["b_ljVHgm0tgjz","$D2025-12-29T18:32:23.051Z"],["b_wDvO1RajhhZ","$D2025-12-29T18:32:40.001Z"],["b_lSYglfO2XQL","$D2025-12-29T18:40:15.385Z"],["b_OyEBOTSd3VW","$D2025-12-29T18:49:20.139Z"],["b_1pDE1BLpTNJ","$D2025-12-29T18:54:43.412Z"],["b_BNdHgCJwuoy","$D2025-12-29T18:55:14.032Z"],["b_Tt6Fcy3m4KA","$D2025-12-29T19:00:53.944Z"],["b_avF50MS4uYy","$D2025-12-29T19:06:08.548Z"],["b_NEa0BjdWWuK","$D2025-12-29T19:45:13.406Z"],["b_zckVaoEsoZi","$D2025-12-29T19:55:20.013Z"],["b_y3mHiQI6GJG","$D2025-12-29T20:06:25.926Z"],["b_CN9KISElagu","$D2025-12-29T20:06:57.049Z"],["b_XhS3iwJYKZb","$D2025-12-29T20:16:33.304Z"],["b_NLE8uBAND69","$D2025-12-29T20:43:44.115Z"],["b_o0gUmyZgWvJ","$D2025-12-29T21:03:56.797Z"],["b_3eywLOnTYKj","$D2025-12-29T21:04:15.359Z"],["b_26kXmJ9GBWQ","$D2025-12-29T21:12:36.293Z"],["b_TyduxhHcdJd","$D2025-12-30T00:03:34.992Z"],["b_TnAGkQgNt8j","$D2025-12-30T00:04:01.584Z"],["b_KmBk47K8nLG","$D2025-12-30T00:21:56.253Z"],["b_F971oukwIdv","$D2025-12-30T00:29:56.751Z"],["b_YOlfjHlS2It","$D2025-12-30T00:30:23.115Z"],["b_6E9TJJkeOJ8","$D2025-12-30T00:31:49.771Z"],["b_tOa2WNS3ZGs","$D2025-12-30T00:32:25.350Z"],["b_9OnTZ15XXaG","$D2025-12-30T00:39:36.945Z"],["b_DTEcxNbQtZM","$D2025-12-30T00:57:31.303Z"],["b_REayn40plNt","$D2025-12-30T01:01:13.118Z"],["b_paOcchAS2jr","$D2025-12-30T01:09:33.181Z"],["b_PeSI6KEUQaf","$D2025-12-30T01:15:38.314Z"],["b_Pfh3H5GRPvA","$D2025-12-30T01:20:08.968Z"],["b_GVvHTk5FxWj","$D2025-12-30T01:25:36.475Z"],["b_UaXRl8vfIlo","$D2025-12-30T01:33:38.386Z"],["b_lBE3Pntbgs6","$D2025-12-30T01:36:44.156Z"],["b_0L10Adjks5H","$D2025-12-30T01:43:15.122Z"],["b_mkpDHu6EqXx","$D2025-12-30T01:47:27.168Z"],["b_LS5ZgnhBrd7","$D2025-12-30T01:54:19.647Z"],["b_kIaNE1yCh5F","$D2025-12-30T01:56:02.862Z"],["b_GaYcSUkkyVt","$D2025-12-30T02:01:26.570Z"],["b_M4Lr3U4fP7A","$D2025-12-30T02:02:26.291Z"],["b_XSL9s12hSa1","$D2025-12-30T02:06:47.130Z"],["b_vos91Wv4h9f","$D2025-12-30T02:14:06.080Z"],["b_QH8HKrqeR1i","$D2025-12-31T00:06:48.803Z"],["b_7BTUTn0DvWO","$D2025-12-31T00:10:42.886Z"],["b_vghck73Mer0","$D2025-12-31T00:15:23.271Z"],["b_FRde6aB8tyr","$D2025-12-31T00:20:24.543Z"],["b_QDukiDV8Td9","$D2025-12-31T02:15:31.734Z"],["b_ALolSCA8Wqn","$D2025-12-31T02:22:54.600Z"],["b_j269mhEs0Bg","$D2025-12-31T02:28:54.438Z"],["b_yCiXd9YaNwj","$D2025-12-31T02:35:08.115Z"],["b_NPNsjwP8RYG","$D2025-12-31T02:36:35.669Z"],["b_KvOkPJH3sXz","$D2025-12-31T02:40:15.674Z"],["b_YZARE4TYgVU","$D2025-12-31T03:02:52.347Z"],["b_P5IdZQABBxw","$D2025-12-31T03:03:34.378Z"],["b_p4SxUo9mqzI","$D2025-12-31T03:04:23.292Z"],["b_pUQoIjcm2J4","$D2025-12-31T03:16:50.350Z"],["b_rxShhZb3mWL","$D2025-12-31T03:17:20.157Z"],["b_0ou69cOWLlZ","$D2025-12-31T03:24:12.351Z"],["b_Lul5g6ZqJhw","$D2025-12-31T03:25:08.127Z"],["b_fVbEvCUTENZ","$D2025-12-31T03:32:50.300Z"],["b_crApTmMLMKU","$D2025-12-31T03:51:10.454Z"],["b_BFB0RDfBOLY","$D2025-12-31T04:54:50.438Z"],["b_ZCXwMfZBWu1","$D2025-12-31T13:15:10.455Z"],["b_mi98D22IPq5","$D2025-12-31T13:25:10.293Z"],["b_YHjZuF63XFE","$D2025-12-31T13:26:10.707Z"],["b_NviOVMgnKxG","$D2025-12-31T13:32:53.246Z"],["b_wOyc0GLioWO","$D2026-01-01T00:20:48.139Z"],["b_JKOeELXk6aS","$D2026-01-01T00:22:47.845Z"],["b_nOuF3ETwhZv","$D2026-01-01T00:23:41.228Z"],["b_Qdfmlt8n6Ya","$D2026-01-01T00:32:47.134Z"],["b_D4WuChXAGdu","$D2026-01-01T00:42:20.105Z"],["b_tvOtNPZiitp","$D2026-01-01T19:12:38.307Z"],["b_XEe1oC0nI8P","$D2026-01-01T19:17:12.230Z"],["b_ZTcBvc6P8j5","$D2026-01-01T19:22:52.630Z"],["b_bfTHyXXPP6E","$D2026-01-01T19:33:27.102Z"],["b_lSFdMzODKYV","$D2026-01-01T19:44:57.871Z"],["b_bPPoaARuJK1","$D2026-01-01T19:49:11.011Z"],["b_6FbNZOR8eqm","$D2026-01-01T19:53:51.999Z"],["b_y0UsYTY07We","$D2026-01-01T19:59:55.918Z"],["b_dqV4hMBG6cf","$D2026-01-01T20:09:54.037Z"],["b_TVE4sOlqczL","$D2026-01-01T20:13:32.398Z"],["b_QEBiIv7nh49","$D2026-01-01T20:14:33.945Z"],["b_98EJp4yElUm","$D2026-01-01T20:19:57.002Z"],["b_ePoeWGXf8QE","$D2026-01-01T20:37:33.248Z"],["b_aiFTz5Kpy3W","$D2026-01-01T20:38:40.933Z"],["b_PRTr7mNYKfD","$D2026-01-01T20:46:31.003Z"],["b_7452lG54Eqa","$D2026-01-01T20:52:50.439Z"],["b_2tke7YY9G3b","$D2026-01-01T20:58:00.041Z"],["b_3moHQY5L48A","$D2026-01-01T21:17:38.516Z"],["b_tbCOes6gUQi","$D2026-01-01T21:18:58.656Z"],["b_cYuW8ehYniC","$D2026-01-01T21:27:34.052Z"],["b_Trw6YL9qUt4","$D2026-01-01T21:37:43.663Z"],["b_rgAZrx1sdLY","$D2026-01-01T22:08:19.219Z"],["b_p6Vbz7f3b5N","$D2026-01-01T22:26:51.662Z"],["b_4G4i5XkEHZ5","$D2026-01-01T22:27:18.285Z"],["b_nqsWdAks8XQ","$D2026-01-01T22:28:14.061Z"],["b_satBiFtFRZ9","$D2026-01-01T22:29:08.685Z"],["b_BMS0wN6zXei","$D2026-01-01T22:34:03.118Z"],["b_sNFzQQ1oKVm","$D2026-01-02T01:18:22.357Z"],["b_auSecFCkVvf","$D2026-01-02T01:18:54.427Z"],["b_eejLIEfgy7t","$D2026-01-02T01:22:06.756Z"],["b_zBaYq67RdP7","$D2026-01-02T01:42:16.828Z"],["b_o8qIScaQSIk","$D2026-01-02T02:05:18.625Z"],["b_XTw52PA4TtN","$D2026-01-02T02:11:32.476Z"],["b_iI13R6D0Pcc","$D2026-01-02T02:15:20.042Z"],["b_yWIK8Ls9EsE","$D2026-01-02T02:16:12.084Z"],["b_Z8pg44hHgWb","$D2026-01-03T01:10:11.128Z"],["b_Aa8jH2P8tAI","$D2026-01-03T01:10:31.514Z"],["b_8QTrswv4MGZ","$D2026-01-03T01:14:54.045Z"],["b_FLLlBifntII","$D2026-01-03T01:21:32.488Z"],["b_XkZKh6W6LhY","$D2026-01-03T01:22:28.933Z"],["b_guSoR5smMxj","$D2026-01-04T01:47:13.458Z"],["b_455VXaAbmDd","$D2026-01-04T01:47:40.143Z"],["b_5lfMzDlEcq0","$D2026-01-04T01:54:21.736Z"],["b_7ncZDxrC4Z6","$D2026-01-04T01:55:06.455Z"],["b_KXhVpLfKC3e","$D2026-01-04T02:00:26.764Z"],["b_Id0L6axuWxn","$D2026-01-04T02:04:21.791Z"],["b_2PHDxbuLiAj","$D2026-01-05T02:37:10.132Z"],["b_5LSakwIKIRg","$D2026-01-05T02:37:29.535Z"],["b_LowaxBOuWb6","$D2026-01-05T03:16:12.556Z"],["b_42YKNoAovfW","$D2026-01-06T02:22:37.982Z"],["b_v6kGdlFvVpF","$D2026-01-06T02:27:27.891Z"],["b_t3ApoyofR8S","$D2026-01-06T02:50:48.643Z"],["b_sabHn8vKC5r","$D2026-01-07T01:46:54.871Z"],["b_9rbhvVIT5bH","$D2026-01-07T01:52:13.713Z"],["b_iDzNcIO9i1i","$D2026-01-07T01:59:26.357Z"],["b_ZtZhIs1Sw6N","$D2026-01-07T02:07:29.543Z"],["b_nLJ7Qm3P1mg","$D2026-01-08T01:41:06.433Z"],["b_XtGZicELa4Q","$D2026-01-08T01:46:01.893Z"],["b_ydmreJDSrHn","$D2026-01-08T01:51:33.874Z"],["b_30RFsYdfUFd","$D2026-01-08T02:07:37.409Z"],["b_K5uLyYJMi5m","$D2026-01-08T02:16:04.146Z"],["b_B8qa1abVWrt","$D2026-01-09T02:37:19.780Z"],["b_8AZuT7QwLFa","$D2026-01-10T00:52:42.227Z"],["b_F2qQgdoiUsh","$D2026-01-10T01:06:17.544Z"],["b_BWZjKpFh1jI","$D2026-01-10T01:07:01.613Z"],["b_oxBmfCQXSQu","$D2026-01-11T01:26:49.067Z"],["b_4aM4utcPOdb","$D2026-01-11T01:31:36.123Z"],["b_qIIU4a605Y1","$D2026-01-12T00:17:16.741Z"],["b_BHyk4GadcKU","$D2026-01-12T00:21:09.423Z"],["b_6br01IXmhct","$D2026-01-12T00:30:07.971Z"],["b_XBODmzy3Gvp","$D2026-01-12T23:17:57.171Z"],["b_mb9V0mklVCh","$D2026-01-19T17:02:44.742Z"],["b_my8DqlMJv9E","$D2026-01-19T17:03:28.832Z"],["b_iDGkAPNl0zd","$D2026-01-19T17:03:41.486Z"],["b_EXGWa1ltoHt","$D2026-01-19T17:03:55.372Z"],["b_wrQo70LOlgo","$D2026-01-19T17:04:06.333Z"],["b_pScWVIOyNNe","$D2026-01-19T17:04:18.375Z"],["b_dubG8q64nUP","$D2026-01-19T17:04:34.933Z"],["b_Paa9AwXz3Ip","$D2026-01-19T17:04:47.970Z"],["b_xR8fHzHFAyy","$D2026-01-19T17:04:57.344Z"],["b_32tyY1fjRDB","$D2026-01-19T17:05:12.980Z"],["b_x8xpNXj0GFS","$D2026-01-19T17:05:32.481Z"],["b_O4BfmecH2UC","$D2026-01-19T17:08:11.724Z"],["b_jV1IS8psweH","$D2026-03-18T22:53:04.368Z"],["b_Nw2P4ZHxO2H","$D2026-03-18T22:55:17.077Z"],["b_27Tf8t5q3Pg","$D2026-03-18T22:58:12.271Z"],["b_BlSr8giqub9","$D2026-03-18T23:00:04.896Z"],["b_rw7Ry0fSxYe","$D2026-03-18T23:00:25.234Z"],["b_lYkwDnreUD4","$D2026-03-18T23:00:38.530Z"],["b_k7743Cxrgj1","$D2026-03-19T22:06:51.102Z"],["b_FC2QE29Nl5m","$D2026-03-19T22:07:45.359Z"],["b_eZuZzphzges","$D2026-03-19T22:08:11.813Z"],["b_IVlHD9bkNy9","$D2026-03-19T22:10:42.794Z"],["b_CfdAonCYPEX","$D2026-03-19T22:11:27.065Z"],["b_JI7CvY426wJ","$D2026-03-19T22:12:19.372Z"],["b_RBlqssYGUwQ","$D2026-03-19T22:13:18.382Z"],["b_XzrGWmyP837","$D2026-03-19T22:14:21.526Z"],["b_7Dc2Rr3TjYX","$D2026-03-19T22:15:04.512Z"],["b_CFT6fTUWXSu","$D2026-03-19T22:15:36.523Z"],["b_tg3SclTnOuL","$D2026-03-19T22:16:07.922Z"],["b_0uwJye5EHUq","$D2026-03-19T22:16:38.887Z"],["b_yYbwQDFXMM9","$D2026-03-19T22:16:48.681Z"],["b_0WoB5vDo4J9","$D2026-03-19T22:17:08.436Z"],["b_9mdg2rNLmU3","$D2026-03-19T22:17:37.786Z"],["b_zaUlz4tdVPH","$D2026-03-19T22:18:42.708Z"],["b_fxVhKb8IJWI","$D2026-03-19T22:19:28.150Z"],["b_tHJnHxQNpG3","$D2026-03-19T22:19:35.783Z"],["b_skptfqrtMM9","$D2026-03-19T22:20:02.425Z"],["b_mkslUM59UsA","$D2026-03-19T22:21:32.796Z"],["b_3V4e2BhWtoF","$D2026-03-19T22:21:58.236Z"],["b_GeYuSLB4c7S","$D2026-03-19T22:22:40.246Z"],["b_a1g8qqTJKLd","$D2026-03-19T22:22:53.251Z"],["b_kVsh4DqtVAN","$D2026-03-19T22:23:31.206Z"],["b_lYuPgBFDrrw","$D2026-03-19T22:24:12.907Z"],["b_fcK9tRj2XlC","$D2026-03-19T22:25:18.925Z"],["b_2EnolEjMUaD","$D2026-03-20T00:19:44.108Z"],["b_mmK7VPrMd6t","$D2026-03-20T00:20:03.082Z"],["b_vmpkemvkmZW","$D2026-03-20T00:20:56.647Z"],["b_eisYgsn6FlO","$D2026-03-20T00:22:45.221Z"],["b_t0X7kkCPkmE","$D2026-03-20T00:23:17.188Z"],["b_k6JDHXqHIX1","$D2026-03-20T00:23:49.261Z"],["b_mX3jixYNSLC","$D2026-03-20T00:24:32.714Z"],["b_gC9MducZNYv","$D2026-03-20T00:26:19.563Z"],["b_ej6wkysb6LE","$D2026-03-20T00:26:57.784Z"],["b_G4bcNneQJBv","$D2026-03-20T00:27:11.879Z"],["b_pxMPX6vHdQl","$D2026-03-20T00:27:36.373Z"],["b_rhsJCJjLQ96","$D2026-03-25T14:08:46.379Z"],["b_rbMBnHX7Rnf","$D2026-03-25T14:08:58.993Z"],["b_hzjnb8f2llr","$D2026-03-25T14:09:11.931Z"],["b_6lZ4R7uegeF","$D2026-03-25T14:11:52.414Z"],["b_xhLinISyUGQ","$D2026-03-25T15:45:30.927Z"],["b_X8dinZI1PCj","$D2026-03-25T15:45:55.235Z"],["b_UlhMmB1N2Gq","$D2026-03-25T15:46:35.821Z"],["b_yWMpoVIrlHs","$D2026-03-25T15:48:01.302Z"],["b_CmqgnH4n4ck","$D2026-03-25T15:48:12.211Z"],["b_GFoPW7ThbY5","$D2026-03-25T15:48:34.964Z"],["b_WqqPSHt3h2c","$D2026-03-25T15:49:22.927Z"],["b_UYdT0OtRB0R","$D2026-03-25T15:50:09.109Z"],["b_UxrLinBYW4R","$D2026-03-25T15:50:30.630Z"],["b_ngHZfajrWsN","$D2026-03-25T15:50:42.444Z"],["b_gxyIxHb7oGl","$D2026-03-25T15:50:53.444Z"],["b_h4rNcKpsPmA","$D2026-03-25T15:51:35.549Z"],["b_55Qqt6BTR6G","$D2026-03-25T15:52:33.537Z"],["b_zMZ29rghpJN","$D2026-03-25T15:52:47.148Z"],["b_TGCaAqpEJUZ","$D2026-03-25T15:54:02.431Z"],["b_VQir9qCrlfv","$D2026-03-25T15:54:34.537Z"],["b_GR1As7ks7j2","$D2026-03-25T15:57:24.401Z"],["b_ZJMM91H2xEV","$D2026-03-25T15:57:42.489Z"],["b_xPm3HC61eYh","$D2026-03-25T15:58:33.748Z"],["b_gQGwZDi1Fpw","$D2026-03-29T15:24:14.622Z"],["b_ROuKBl68VGj","$D2026-03-29T15:24:36.199Z"],["b_CPHUueoxu3V","$D2026-03-29T15:24:46.536Z"],["b_JhMkpPD7hNK","$D2026-03-29T15:25:00.715Z"],["b_KG83fg09v8Z","$D2026-03-29T15:25:13.300Z"],["b_nVTTDlU6tPx","$D2026-03-29T15:26:56.502Z"],["b_NVbrO29MQ9U","$D2026-03-30T10:54:03.554Z"],["b_ziXJHvSDgE9","$D2026-03-30T10:54:18.536Z"],["b_rJN2R9bgBEs","$D2026-03-30T10:54:35.437Z"],["b_ZSeQ06VnVz4","$D2026-03-30T10:54:48.140Z"],["b_qqaT9dBCrd2","$D2026-03-30T10:55:00.767Z"],["b_YWumc0aAk23","$D2026-03-30T10:55:14.489Z"],["b_2ntfvsZJQsh","$D2026-03-30T10:55:25.628Z"],["b_iEyBjXBcWS0","$D2026-03-30T10:55:52.088Z"],["b_QPQtr4zUUEM","$D2026-03-30T10:56:05.360Z"],["b_ZAz4mmAmgQG","$D2026-04-23T22:03:56.241Z"],["b_XJDTs3bKukB","$D2026-04-23T22:04:19.151Z"],["b_tpndQum0goL","$D2026-04-23T22:05:01.210Z"],["b_770rV3SyLG1","$D2026-04-23T22:05:15.335Z"],["b_x8dkfVmp8aC","$D2026-04-23T22:05:28.340Z"],["b_oRDZ1GpHlp1","$D2026-04-23T22:05:56.052Z"],["b_dZlkqes1Auh","$D2026-04-23T22:17:06.660Z"],["b_fJVaLAEhHlq","$D2026-04-23T22:17:37.372Z"],["b_H4CH7TLLJEt","$D2026-04-23T22:18:03.963Z"],["b_3XMfVyEUn3T","$D2026-04-23T22:18:34.311Z"],["b_G9CONon1KVE","$D2026-04-23T22:19:10.370Z"],["b_NzkeareH5wl","$D2026-04-23T22:19:41.467Z"],["b_TyPGpPY2l27","$D2026-04-23T22:28:04.338Z"],["b_EwuOcum9jh2","$D2026-04-23T22:28:13.571Z"],["b_GpzwSxH7TLa","$D2026-04-23T22:28:34.475Z"],["b_OVqViziAtGY","$D2026-04-23T22:28:43.608Z"],["b_XsblNiSbB7l","$D2026-04-23T22:28:53.195Z"],["b_CoZPadRDCj6","$D2026-04-23T22:29:08.638Z"],["b_DJ2ikGid9Gz","$D2026-04-23T22:33:04.850Z"],["b_Kg0XwxxTvhC","$D2026-04-23T22:33:14.590Z"],["b_Owc2hKxzVc4","$D2026-04-24T18:57:56.609Z"],["b_CXf2T5J3bxA","$D2026-04-24T18:58:29.294Z"],["b_xLXdpdrpnpK","$D2026-04-24T18:58:52.745Z"],["b_V9NXGXwSTDO","$D2026-04-24T18:59:29.461Z"],["b_u4qL2LdIL0O","$D2026-04-24T18:59:40.076Z"],["b_dD2KAWf6uPZ","$D2026-04-24T21:16:51.142Z"],["b_CiPNnwNiJvo","$D2026-04-24T21:17:11.621Z"],["b_lwOerobE8Jm","$D2026-04-24T21:22:19.445Z"],["b_RNdYOIqdje3","$D2026-04-24T21:22:34.201Z"],["b_7EY11fKaxT6","$D2026-04-24T21:22:53.893Z"],["b_KVqlBqxCjAd","$D2026-04-24T21:23:11.932Z"],["b_ngl47AGLOrG","$D2026-04-24T21:23:21.954Z"],["b_y55RZmAFOBt","$D2026-04-24T21:23:36.514Z"],["b_W0v3y6pU5mN","$D2026-04-24T21:45:02.311Z"],["b_wVV7RCAZjda","$D2026-04-24T21:45:24.806Z"],["b_8lswckPH3aR","$D2026-04-24T21:45:59.723Z"],["b_Djr0Q3mtBoZ","$D2026-04-24T21:46:12.459Z"],["b_SkfJ2r03C8J","$D2026-05-17T14:51:41.219Z"],["b_8rmlF6MwsMw","$D2026-05-17T14:52:54.396Z"],["b_MKx7zi1SkAT","$D2026-05-17T14:53:12.084Z"],["b_5rzVWule5ld","$D2026-05-17T14:53:28.478Z"],["b_vPEa1MBHDe7","$D2026-05-17T14:53:50.174Z"],["b_i9ImiQvAMJr","$D2026-05-17T15:00:08.694Z"],["b_KqHmrFK3VJw","$D2026-05-17T15:22:04.626Z"],["b_ZnFlq8aplqb","$D2026-05-17T15:22:36.077Z"],["b_ypV8Hdpbd4y","$D2026-05-17T15:38:46.963Z"],["b_ifuxCv9V9VX","$D2026-05-17T15:39:18.129Z"],["b_6X2lNRufXaD","$D2026-05-17T15:40:23.637Z"],["b_dPPVO4Tt1xi","$D2026-05-17T15:49:28.196Z"],["b_gAfFTALhquB","$D2026-05-17T15:49:58.171Z"],["b_TQo7yR8WHrH","$D2026-05-17T15:50:24.625Z"],["b_IljgJDUVPM6","$D2026-05-17T15:59:04.017Z"],["b_oamwcSzTQoK","$D2026-05-17T15:59:25.943Z"],["b_0tVTjyml1Fm","$D2026-05-17T15:59:45.881Z"],["b_XGG4wRBSAUA","$D2026-05-17T16:00:15.776Z"],["b_hOYsK8nP08j","$D2026-05-17T16:00:56.963Z"],["b_Wfom0fhDCzC","$D2026-05-17T16:07:08.307Z"],["b_6mVonONFPj5","$D2026-05-17T16:07:29.665Z"],["b_OOm7cbma1KY","$D2026-05-17T16:07:54.932Z"],["b_roTwBhKti3s","$D2026-05-17T16:08:17.186Z"],["b_kyommUVzbFJ","$D2026-05-17T16:08:42.545Z"],["b_xUmoY0pTqe3","$D2026-05-17T16:09:03.817Z"],["b_X6ZRMHnG1My","$D2026-05-17T16:09:30.205Z"],["b_v4lO0EfN5aD","$D2026-05-17T16:09:57.581Z"],["b_t8LbZ6LYKuh","$D2026-05-17T16:26:35.476Z"],["b_kegInNlcXCh","$D2026-05-17T16:27:39.226Z"],["b_8LZSPZeVEYO","$D2026-05-17T16:32:19.641Z"],["b_08h1yNxhKa2","$D2026-05-17T16:36:14.187Z"],["b_ldNqtPtGtoH","$D2026-05-17T16:36:41.540Z"],["b_GiUQB6831Yn","$D2026-05-17T16:37:14.244Z"],["b_MhatfadUAYT","$D2026-05-17T16:37:43.592Z"],["b_eKP9bdfAIbY","$D2026-05-17T16:38:15.352Z"],["b_YGyJlR53BQE","$D2026-05-17T16:38:48.545Z"],["b_Yt1L2PxUPWt","$D2026-05-17T16:39:33.639Z"],["b_cudwBrkzENq","$D2026-05-17T16:40:39.441Z"],["b_ZXduMnuzckP","$D2026-05-17T16:52:04.750Z"],["b_1wUOdL3a9B8","$D2026-05-17T16:52:34.895Z"],["b_rkZjmRgDd7P","$D2026-05-17T17:04:57.058Z"],["b_7jw7IUK8iQW","$D2026-05-17T17:05:28.302Z"],["b_UQ9VRhitPyb","$D2026-05-17T17:05:55.572Z"],["b_NP3fVSjDHYO","$D2026-05-17T17:31:39.235Z"],["b_rtlirrSpaGB","$D2026-05-17T17:32:27.728Z"],["b_rucGoodCvaW","$D2026-05-17T17:41:10.121Z"],["b_8UPVBdM8pzz","$D2026-05-17T17:41:39.063Z"],["b_Sr8lgnYB6es","$D2026-05-17T17:41:56.436Z"],["b_JWWMZJdNMPk","$D2026-05-17T17:46:27.554Z"],["b_cdAP9LDxHJJ","$D2026-05-17T17:46:58.095Z"],["b_IlnEnVEeEEY","$D2026-05-18T18:35:08.153Z"],["b_HcjCDB5lSs9","$D2026-05-18T18:35:45.387Z"],["b_mxpVvOIM7r6","$D2026-05-18T18:37:57.507Z"],["b_CrcGPxAr0PZ","$D2026-05-18T18:38:14.485Z"],["b_0lZPxfmNR1s","$D2026-05-18T18:38:36.824Z"],["b_Vww3RY1uV3N","$D2026-05-18T18:39:10.188Z"],["b_lA3Qy6TjyZf","$D2026-05-18T18:39:42.560Z"],["b_SBzy2AKvqqw","$D2026-05-18T18:40:09.562Z"],["b_iCfiqijYkbq","$D2026-05-19T17:41:16.113Z"],["b_8xiLTVwKnnO","$D2026-05-19T17:41:45.625Z"],["b_14Bur9BVNv7","$D2026-05-19T17:42:16.677Z"],["b_xjkGRhovDSn","$D2026-05-19T17:43:02.841Z"],["b_rMh8xlxr3sP","$D2026-05-19T17:43:59.209Z"],["b_d5Bhq0ZCmuc","$D2026-05-19T17:44:16.199Z"],["b_W4X6cnhjzws","$D2026-05-20T16:25:09.039Z"],["b_HmLy21OsXMV","$D2026-05-20T16:25:25.596Z"],["b_pjbYOjCIBI0","$D2026-05-20T16:25:47.401Z"],["b_mAtQkpbw8MT","$D2026-05-20T16:26:22.631Z"],["b_EEsNNuDCSVd","$D2026-05-20T16:27:04.388Z"],["b_GrMfD3ICiW3","$D2026-05-20T16:27:42.276Z"],["b_2lifGeNOnk4","$D2026-05-20T16:28:10.401Z"],["b_13Y49sO6aWz","$D2026-05-20T16:28:28.318Z"],["b_6bnLGaiEYeB","$D2026-05-20T16:28:44.111Z"],["b_kNvwyUY53uC","$D2026-05-20T16:29:00.115Z"],["b_hvuFhpIwFOR","$D2026-05-20T16:29:20.963Z"],["b_p2dYI1U88no","$D2026-05-20T16:29:55.001Z"],["b_8oooYfAP1qR","$D2026-05-24T16:56:59.678Z"],["b_xRRFcInociS","$D2026-05-24T16:57:31.096Z"],["b_s6MUdoJOPNB","$D2026-05-24T16:58:00.714Z"],["b_TfXik2QzEcU","$D2026-05-24T16:58:28.570Z"],["b_QLI2FooN9fo","$D2026-05-24T16:58:44.329Z"],["b_e0LFolaqfYQ","$D2026-05-24T16:58:58.771Z"],["b_2EeNfGYwPfG","$D2026-05-24T16:59:19.256Z"],["b_AkZtgBiWLUU","$D2026-05-24T16:59:49.105Z"],["b_a6fjbPjzcrP","$D2026-05-24T17:00:25.798Z"],["b_6Z09myaad9n","$D2026-05-24T17:01:19.994Z"],["b_vDzzmAFAh3f","$D2026-05-25T17:17:55.507Z"],["b_uyCz6HemOQQ","$D2026-05-25T17:18:13.008Z"],["b_ThnTaijefsK","$D2026-05-25T17:18:35.733Z"],["b_hyeA2RfRUG9","$D2026-05-25T17:18:51.825Z"],["b_r9JV7Hp8use","$D2026-05-25T17:19:07.324Z"],["b_jo4sxSgnDDG","$D2026-05-25T17:19:38.019Z"],["b_7ZUvNCwtE06","$D2026-05-25T17:20:12.391Z"],["b_4vCPw9t0lm0","$D2026-05-25T17:20:40.878Z"],["b_HCP0HqyrXmv","$D2026-05-25T17:21:12.848Z"],["b_Z8tb1DE103a","$D2026-05-25T17:21:50.784Z"],["b_BuUlTERsLUa","$D2026-05-25T17:22:08.296Z"],["b_NBMUnLjHqOD","$D2026-05-25T17:22:43.335Z"],["b_qcdjRogkAZI","$D2026-05-27T10:51:48.395Z"],["b_6j74lLtfUxf","$D2026-05-27T10:52:09.113Z"],["b_h92n8ZUlDr7","$D2026-05-27T10:52:48.351Z"],["b_oWQcSMr4HKY","$D2026-05-27T10:53:15.131Z"],["b_FZ9LLNhNRXb","$D2026-05-27T10:53:32.969Z"],["b_w88nN4t3l5m","$D2026-05-27T10:54:02.302Z"],["b_oc4v3jDZAGn","$D2026-05-27T10:54:44.395Z"],["b_yFUAMpCJbtv","$D2026-05-27T10:55:17.117Z"],["b_f1RAyNygpbC","$D2026-05-27T10:55:49.964Z"],["b_wbfFDABFFQg","$D2026-05-27T10:56:09.575Z"],["b_dzvVIwIU22C","$D2026-05-27T10:56:28.489Z"],["b_bYST4MXP3xz","$D2026-05-27T10:57:11.983Z"],["b_MqsMIkT5vGC","$D2026-05-27T10:57:52.654Z"],["b_fFf05xXRNt6","$D2026-05-30T17:41:20.916Z"],["b_uH5MVtZKumf","$D2026-05-30T17:41:38.448Z"],["b_1L81c0JxXU0","$D2026-05-30T17:41:59.585Z"],["b_BRRxpMcZ8xC","$D2026-05-30T17:42:14.275Z"],["b_luA7baCzR1E","$D2026-05-30T17:42:27.856Z"],["b_rQF5qH1o5d8","$D2026-05-30T17:42:58.425Z"],["b_RaJfZemeRvH","$D2026-05-30T17:43:30.794Z"],["b_RTcZyu03ugj","$D2026-05-30T17:44:13.254Z"],["b_r2L5TW54VCV","$D2026-05-30T17:44:27.454Z"],["b_0EWbHVoG022","$D2026-05-30T17:45:02.080Z"],["b_JPBk64p1UUy","$D2026-05-30T17:45:28.271Z"],["b_xPgud5OTBJy","$D2026-05-31T20:10:39.404Z"],["b_UgclhNoijY8","$D2026-05-31T20:10:58.189Z"],["b_1zmsvaMVZQs","$D2026-05-31T20:11:21.379Z"],["b_qhUkJBAwA3J","$D2026-05-31T20:11:37.951Z"],["b_qnHQU2Nd1x3","$D2026-05-31T20:11:54.603Z"],["b_VYS0cpCtEZm","$D2026-05-31T20:12:26.209Z"],["b_xbXlsrvBDfs","$D2026-05-31T20:13:02.269Z"],["b_p9TPltm3qej","$D2026-05-31T20:13:33.099Z"],["b_F4dyXeN4Voc","$D2026-05-31T20:14:27.018Z"],["b_v83uAlGa5iP","$D2026-05-31T20:15:04.608Z"],["b_jB5djbzSI6I","$D2026-05-31T20:15:40.049Z"],["b_T1mJTuutCS9","$D2026-06-05T17:49:51.965Z"],["b_1SgMC5RN7RZ","$D2026-06-05T17:50:11.746Z"],["b_Uubby7Cwof3","$D2026-06-05T17:50:35.379Z"],["b_ZLecvsjF3PM","$D2026-06-05T17:50:55.337Z"],["b_Cn98etmbdqd","$D2026-06-05T17:51:10.570Z"],["b_ZGOcGhbpvmE","$D2026-06-05T17:51:43.288Z"],["b_dQRASEAhPPV","$D2026-06-05T17:52:17.552Z"],["b_uOJOr4SEBw6","$D2026-06-05T17:52:44.918Z"],["b_q4mNaB9zmPa","$D2026-06-13T01:20:56.308Z"],["b_gnYrBr6QDwM","$D2026-06-13T01:21:25.039Z"],["b_DVMJ4reXuIc","$D2026-06-13T01:21:51.837Z"],["b_u0QCl3dy6NJ","$D2026-06-13T01:22:08.285Z"],["b_zoGgNr9Xigj","$D2026-06-13T01:22:26.130Z"],["b_XA1QH3QmyU5","$D2026-06-13T01:22:43.702Z"],["b_ZRaqmVqBIVr","$D2026-06-26T22:51:55.661Z"],["b_mUhtFhjehjT","$D2026-06-26T22:52:07.444Z"],["b_HuJKMYaEoIp","$D2026-06-26T22:52:18.513Z"],["b_rQjzHBqIMD7","$D2026-06-26T22:52:28.830Z"],["b_aaBcD8BxuQ2","$D2026-06-26T22:52:37.783Z"],["b_28H86GDNA3M","$D2026-06-26T22:52:54.861Z"],["b_oxKK8ksNa7Y","$D2026-06-26T22:53:06.955Z"],["b_muNt4hf0Qi1","$D2026-06-26T22:53:17.732Z"],["b_rs9au8jxGeD","$D2026-06-26T22:53:33.624Z"],["b_LdBjFUlf7Q7","$D2026-06-26T22:53:53.206Z"],["b_9LAToRGl9wL","$D2026-06-26T22:54:20.619Z"],["b_6ihGgNDGzN0","$D2026-06-26T22:54:32.360Z"],["b_pq5wkpBPyvu","$D2026-06-26T22:54:42.927Z"],["b_iYdLWjAhNni","$D2026-06-26T22:54:55.267Z"],["b_w8OjJQQ4Qu2","$D2026-06-26T22:55:21.467Z"],["b_sELVcURPfku","$D2026-06-26T22:55:31.745Z"],["b_6chEPkUOBh5","$D2026-06-26T22:55:51.232Z"],["b_jvjnhWnRJwB","$D2026-06-26T22:56:14.996Z"],["b_w7RXCCVrOjE","$D2026-06-26T22:56:33.214Z"],["b_inp0hZNywVO","$D2026-06-26T22:56:53.131Z"],["b_G7qLUKcDs02","$D2026-06-26T22:57:40.115Z"],["b_cKgeyISzgMw","$D2026-06-26T22:58:03.891Z"],["b_HW1aqa0oJI1","$D2026-06-26T22:58:30.271Z"],["b_fYpyrZ1ivFU","$D2026-06-26T22:58:49.156Z"],["b_wKcK5aQCCp6","$D2026-06-26T22:59:12.729Z"],["b_P0QTXKeXKIv","$D2026-06-26T23:00:09.979Z"],["b_dZHstMkFdzq","$D2026-06-26T23:00:22.925Z"],["b_Y0VWYYjfcVR","$D2026-06-26T23:34:41.702Z"],["b_PZJHCpBRRit","$D2026-06-26T23:34:55.605Z"],["b_mGZ6Fs3o2Kb","$D2026-06-26T23:35:07.572Z"],["b_r2wHBStNl0h","$D2026-06-26T23:35:19.331Z"],["b_4wMYBEJYPZ0","$D2026-06-26T23:35:33.025Z"],["b_v7GcQkhDICr","$D2026-06-26T23:35:46.686Z"],["b_rdQaMo6BW0a","$D2026-06-26T23:36:01.398Z"],["b_0X0hcDx1qvG","$D2026-06-26T23:36:19.500Z"],["b_ScjZQnRx5L9","$D2026-06-26T23:36:34.511Z"],["b_RYKMk01LpTr","$D2026-06-26T23:36:55.671Z"],["b_893JiEClrfE","$D2026-06-26T23:37:07.719Z"],["b_8Rs595ZXGtf","$D2026-06-26T23:37:28.102Z"],["b_LikKLL0UYak","$D2026-06-26T23:37:38.104Z"],["b_p4WK8l5KW5B","$D2026-06-26T23:37:48.038Z"],["b_2FQE27pDSo9","$D2026-06-26T23:38:09.945Z"],["b_I3c3Dhk00I5","$D2026-06-26T23:38:22.927Z"],["b_iwZJ6Lp9m8P","$D2026-06-26T23:38:36.196Z"],["b_JnWDWvemcSu","$D2026-06-26T23:39:02.964Z"],["b_fKW28ifqXlK","$D2026-06-26T23:39:40.210Z"],["b_uUbiBpojPVS","$D2026-06-26T23:40:15.157Z"],["b_DvXAsPdoIOr","$D2026-06-26T23:40:39.206Z"],["b_enbVQjBkpEI","$D2026-06-26T23:40:52.758Z"],["b_rWTt3mkXNa7","$D2026-06-26T23:41:11.676Z"],["b_vj8yGCojQt6","$D2026-06-26T23:41:38.643Z"],["b_qbasdOR5R6N","$D2026-06-26T23:41:56.879Z"],["b_UpIueVdhr4L","$D2026-06-26T23:42:22.271Z"],["b_8BePUPakyfX","$D2026-06-26T23:42:51.348Z"],["b_fCenqH4bqYb","$D2026-06-26T23:43:07.514Z"],["b_ot3wtGF5iGZ","$D2026-06-26T23:43:32.403Z"],["b_v8dWqAfxsi2","$D2026-06-26T23:43:49.722Z"],["b_9sR6sY3m0z4","$D2026-06-26T23:44:25.946Z"],["b_d6twSp1kzsv","$D2026-06-26T23:45:12.118Z"],["b_u7mvhGgoKS1","$D2026-06-26T23:46:03.806Z"],["b_IwQ2ltp1OpS","$D2026-06-26T23:46:50.993Z"],["b_I1vxoeJwMgM","$D2026-06-26T23:47:15.583Z"],["b_O30nUph9k1P","$D2026-06-26T23:58:14.564Z"],["b_9ZHSoM2ArcP","$D2026-06-26T23:58:30.404Z"],["b_EkzEn2VDzcF","$D2026-06-26T23:58:45.196Z"],["b_wEUhGjTBb23","$D2026-06-26T23:59:03.229Z"],["b_k5KTE5yNTzj","$D2026-06-26T23:59:19.197Z"],["b_IqyDjkO7dmM","$D2026-06-27T00:10:14.499Z"],["b_mEAVQ6peWTW","$D2026-06-27T00:10:27.326Z"],["b_EdnVIIcCGCt","$D2026-06-27T00:10:41.970Z"],["b_ET46VHz0Pkb","$D2026-06-27T00:11:07.113Z"],["b_b5dgwGYrtp0","$D2026-06-27T00:11:15.950Z"],["b_mgW8teElI3c","$D2026-06-27T00:11:40.428Z"],["b_RDzQbf6sjLR","$D2026-06-27T00:12:07.369Z"],["b_HUmQ6z5DESf","$D2026-06-27T00:13:01.676Z"],["b_iHcc5WqciXy","$D2026-06-27T00:13:23.130Z"],["b_r8BwJWNcvM8","$D2026-06-27T00:13:36.537Z"],["b_s9dQSGdba8N","$D2026-07-02T20:17:52.509Z"],["b_VwWhFl1V31p","$D2026-07-02T20:18:02.833Z"],["b_f3ttZQwgNjm","$D2026-07-02T20:18:17.678Z"],["b_nNDPoEJVvWW","$D2026-07-02T20:18:48.473Z"],["b_Y6mcSMoie2p","$D2026-07-02T20:19:02.732Z"],["b_grCSYwKyqF2","$D2026-07-13T14:32:43.589Z"],["b_PLvJtUO1WJN","$D2026-07-13T14:32:58.566Z"],["b_cpEa63pu5fE","$D2026-07-13T14:33:10.181Z"],["b_vqPlZxLSCNI","$D2026-07-13T14:33:47.222Z"],["b_nOiCdBAjI3F","$D2026-07-13T14:34:03.545Z"],["b_HH5ythyPPkZ","$D2026-07-13T14:34:46.752Z"],["b_ls4t3WSu9NG","$D2026-07-13T14:35:13.852Z"]] a3:[["b_grCSYwKyqF2",false],["b_PLvJtUO1WJN",false],["b_cpEa63pu5fE",false],["b_vqPlZxLSCNI",false],["b_nOiCdBAjI3F",false],["b_HH5ythyPPkZ",false],["b_ls4t3WSu9NG",false]] a4:[["b_grCSYwKyqF2","$undefined"],["b_PLvJtUO1WJN","$undefined"],["b_cpEa63pu5fE","$undefined"],["b_vqPlZxLSCNI","$undefined"],["b_nOiCdBAjI3F","$undefined"],["b_HH5ythyPPkZ","$undefined"],["b_ls4t3WSu9NG","$undefined"]] a5:[["b_grCSYwKyqF2",null],["b_PLvJtUO1WJN",null],["b_cpEa63pu5fE",null],["b_vqPlZxLSCNI",null],["b_nOiCdBAjI3F",null],["b_HH5ythyPPkZ",null],["b_ls4t3WSu9NG",null]] a6:[["b_grCSYwKyqF2",true],["b_PLvJtUO1WJN",true],["b_cpEa63pu5fE",true],["b_vqPlZxLSCNI",true],["b_nOiCdBAjI3F",true],["b_HH5ythyPPkZ",true],["b_ls4t3WSu9NG",true]] a7:[["b_grCSYwKyqF2",true],["b_PLvJtUO1WJN",true],["b_cpEa63pu5fE",true],["b_vqPlZxLSCNI",true],["b_nOiCdBAjI3F",true],["b_HH5ythyPPkZ",true],["b_ls4t3WSu9NG",true]] a8:[] a9:T5d3,I've identified the sensitive column `encrypted_wallet` and the safe public columns for lookups. My approach is to restrict the default SELECT policy to own-row access, create a security-definer function that exposes only the safe columns for cross-user profile lookups, and then update the code to use this RPC function instead of selecting all columns. But I'm realizing this breaks all the existing cross-user lookups in the send flows unless I route them through the RPC. I need to check which queries are actually cross-user versus own-row, and I'm noticing that admin pages might also break if they're using the browser client instead of service role. Rather than overhauling RLS entirely, a cleaner approach is to use column-level privileges — revoking SELECT on `encrypted_wallet` from authenticated and anon roles while keeping the row-level policy permissive, so the column is simply inaccessible to those roles even in wildcard queries. Wait, that won't work either because the owner needs to read their own `encrypted_wallet` to decrypt it, and column grants aren't row-specific. So I'm back to needing row-level RLS that restricts to own-row, which means I have to update all the cross-user lookups to use an RPC instead. Before I make any changes, I should audit the actual queries — checking the admin pages, wallet sync, and stats routes to see whether they're using service role or the browser client, and which ones are reading other users' profiles versus their own.aa:T5bf,I'm settling on a security approach that uses a SECURITY DEFINER function to safely expose a public search without breaking existing functionality. The strategy involves removing the overly permissive select policy, adding row-level security so users can only see their own profiles, and creating a dedicated search function that returns only non-sensitive columns like id and username. For the cross-user lookups in the payment flows, I'll update those to call the new RPC functions instead of direct queries. The trickier part is the admin users page — since it currently selects all columns and would break under the own-row RLS, I need to create a service-role API route that the admin page can call to fetch the full user data it needs, keeping admin access intact while restricting what regular users can see. I need to handle username availability checks too—they do cross-user reads by username during signup, and under own-row RLS that would break the UX check. There's likely a database unique constraint preventing duplicates anyway, but I should route those checks through a SECURITY DEFINER function as well. So my implementation plan is: create a migration with own-row SELECT policy, drop the permissive one, add `search_profiles` and `get_profile_by_username` SECURITY DEFINER functions returning safe columns, then update the cross-user reads across payment-send, unified-send, admin/users, and the signup/profile-setup flows to use these functions.ab:T4fe,I'm mapping out the cross-user read operations that would fail under row-level security with own-row restrictions. There are several places where the app searches or retrieves user profiles across different users—like the payment send interface querying by username, the admin users page fetching all profiles, and a few other endpoints that need to access data outside their own row. The key insight is that username availability checks would break under own-row RLS since they'd return empty results for other users' usernames, falsely reporting them as available. I need to create a migration that locks down profile reads to own-row access while providing safe RPC functions for cross-user lookups. I'm designing a `search_profiles` function that returns only non-sensitive columns like username, display name, and wallet addresses, which can be called securely to handle these cross-user queries. Writing migration SQL... Anon access is needed during signup for the username check, while authenticated users access profiles after auth — I'll grant execute to both. I need to verify the exact names of existing policies before dropping them, so let me check the saved query results to confirm I'm removing the right ones without leaving any permissive policies behind.ac:T66e,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;ad:T66e,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;ae:T66e,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;af:T6ac,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; DROP POLICY IF EXISTS profiles_select_own ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;b0:T6ac,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; DROP POLICY IF EXISTS profiles_select_own ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;b1:T6ac,-- Lock profiles to own-row reads so encrypted_wallet is never exposed to other users DROP POLICY IF EXISTS profiles_select_all ON public.profiles; DROP POLICY IF EXISTS profiles_select_own ON public.profiles; CREATE POLICY profiles_select_own ON public.profiles FOR SELECT TO authenticated USING (auth.uid() = id); -- Safe partial-username search for the send-by-username feature. -- Returns ONLY non-sensitive columns (never encrypted_wallet). CREATE OR REPLACE FUNCTION public.search_profiles(search_term text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE username ILIKE '%' || search_term || '%' ORDER BY username LIMIT 5; $$; -- Safe exact-username lookup (used for QR scan, recipient resolution, -- and username-availability checks during signup). Non-sensitive columns only. CREATE OR REPLACE FUNCTION public.get_profile_by_username(uname text) RETURNS TABLE ( id uuid, username text, display_name text, wallet_address text, builtin_wallet_address text, has_builtin_wallet boolean ) LANGUAGE sql SECURITY DEFINER SET search_path = public AS $$ SELECT id, username, display_name, wallet_address, builtin_wallet_address, has_builtin_wallet FROM public.profiles WHERE lower(username) = lower(uname) LIMIT 1; $$; GRANT EXECUTE ON FUNCTION public.search_profiles(text) TO authenticated, anon; GRANT EXECUTE ON FUNCTION public.get_profile_by_username(text) TO authenticated, anon;b2:Tf0f94,[V0_FILE]typescriptreact:file="components/ui/input.tsx" isMerged="true" import * as React from "react" import { cn } from "@/lib/utils" const Input = React.forwardRef>( ({ className, type, ...props }, ref) => { return ( ) }, ) Input.displayName = "Input" export { Input } [V0_FILE]xml:file="public/sitemap.xml" isMerged="true" https://linkficrypto.com 2025-01-01 weekly 1.0 [V0_FILE]plaintext:file="public/robots.txt" isMerged="true" # Allow all search engines to crawl the site User-agent: * Allow: / # Sitemap location Sitemap: https://linkficrypto.com/sitemap.xml [V0_FILE]typescriptreact:file="components/token-manager.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { Card } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Plus, Eye, EyeOff, Trash2, RefreshCw } from "lucide-react" import { Badge } from "@/components/ui/badge" interface Token { address: string symbol: string name: string decimals: number balance: string balanceUSD?: string logoURI?: string isCustom?: boolean } interface TokenManagerProps { walletAddress: string provider: any } export function TokenManager({ walletAddress, provider }: TokenManagerProps) { const [tokens, setTokens] = useState([]) const [hiddenTokens, setHiddenTokens] = useState>(new Set()) const [showAddToken, setShowAddToken] = useState(false) const [isLoading, setIsLoading] = useState(false) const [customTokenAddress, setCustomTokenAddress] = useState("") // ERC-20 ABI for balanceOf and token info const ERC20_ABI = [ "function balanceOf(address) view returns (uint256)", "function symbol() view returns (string)", "function name() view returns (string)", "function decimals() view returns (uint8)", ] useEffect(() => { loadTokens() }, [walletAddress]) const loadTokens = async () => { setIsLoading(true) try { // Load popular tokens (you can expand this list) const popularTokens = [ { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", symbol: "USDT", name: "Tether USD", decimals: 6, }, { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", symbol: "USDC", name: "USD Coin", decimals: 6, }, { address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", symbol: "DAI", name: "Dai Stablecoin", decimals: 18, }, { address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", symbol: "WBTC", name: "Wrapped BTC", decimals: 8, }, ] const tokenBalances = await Promise.all( popularTokens.map(async (token) => { try { const balance = await provider.request({ method: "eth_call", params: [ { to: token.address, data: `0x70a08231000000000000000000000000${walletAddress.slice(2)}`, }, "latest", ], }) const balanceNum = Number.parseInt(balance, 16) / Math.pow(10, token.decimals) return { ...token, balance: balanceNum.toFixed(4), } } catch (error) { return { ...token, balance: "0.0000", } } }), ) setTokens(tokenBalances.filter((t) => Number.parseFloat(t.balance) > 0)) } catch (error) { console.error("Error loading tokens:", error) } finally { setIsLoading(false) } } const addCustomToken = async () => { if (!customTokenAddress || !customTokenAddress.startsWith("0x")) { alert("Please enter a valid token address") return } setIsLoading(true) try { // Get token info const symbolData = await provider.request({ method: "eth_call", params: [{ to: customTokenAddress, data: "0x95d89b41" }, "latest"], }) const nameData = await provider.request({ method: "eth_call", params: [{ to: customTokenAddress, data: "0x06fdde03" }, "latest"], }) const decimalsData = await provider.request({ method: "eth_call", params: [{ to: customTokenAddress, data: "0x313ce567" }, "latest"], }) const balanceData = await provider.request({ method: "eth_call", params: [ { to: customTokenAddress, data: `0x70a08231000000000000000000000000${walletAddress.slice(2)}`, }, "latest", ], }) const decimals = Number.parseInt(decimalsData, 16) const balance = Number.parseInt(balanceData, 16) / Math.pow(10, decimals) // Decode hex strings (simplified) const symbol = hexToString(symbolData) const name = hexToString(nameData) const newToken: Token = { address: customTokenAddress, symbol, name, decimals, balance: balance.toFixed(4), isCustom: true, } setTokens([...tokens, newToken]) setCustomTokenAddress("") setShowAddToken(false) } catch (error) { console.error("Error adding custom token:", error) alert("Failed to add token. Please check the address and try again.") } finally { setIsLoading(false) } } const hexToString = (hex: string): string => { try { const cleaned = hex.replace("0x", "") let str = "" for (let i = 0; i < cleaned.length; i += 2) { const charCode = Number.parseInt(cleaned.substr(i, 2), 16) if (charCode > 0) str += String.fromCharCode(charCode) } return str.trim() } catch { return "Unknown" } } const toggleTokenVisibility = (address: string) => { const newHidden = new Set(hiddenTokens) if (newHidden.has(address)) { newHidden.delete(address) } else { newHidden.add(address) } setHiddenTokens(newHidden) } const removeCustomToken = (address: string) => { setTokens(tokens.filter((t) => t.address !== address)) } const visibleTokens = tokens.filter((t) => !hiddenTokens.has(t.address)) return (

Token Balances

{showAddToken && (

Add Custom Token

setCustomTokenAddress(e.target.value)} />

)}

{visibleTokens.length === 0 ? (

No tokens found

Add custom tokens or wait for balances to load

) : ( visibleTokens.map((token) => (

{token.symbol.slice(0, 2)}

{token.symbol}

{token.isCustom && Custom}

{token.name}

{token.balance}

{token.balanceUSD &&

${token.balanceUSD}

}

{token.isCustom && ( )}

)) )}

{hiddenTokens.size > 0 && (

)} ) } [V0_FILE]typescriptreact:file="components/network-switcher.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { Button } from "@/components/ui/button" import { Card } from "@/components/ui/card" import { Check, ChevronDown } from "lucide-react" interface Network { chainId: string name: string rpcUrl: string symbol: string explorer: string icon: string } interface NetworkSwitcherProps { provider: any onNetworkChange?: (network: Network) => void } export function NetworkSwitcher({ provider, onNetworkChange }: NetworkSwitcherProps) { const [currentNetwork, setCurrentNetwork] = useState(null) const [showNetworks, setShowNetworks] = useState(false) const [isSwitching, setIsSwitching] = useState(false) const networks: Network[] = [ { chainId: "0x1", name: "Ethereum Mainnet", rpcUrl: "https://mainnet.infura.io/v3/", symbol: "ETH", explorer: "https://etherscan.io", icon: "⟠", }, { chainId: "0x38", name: "BNB Smart Chain", rpcUrl: "https://bsc-dataseed.binance.org/", symbol: "BNB", explorer: "https://bscscan.com", icon: "🔶", }, { chainId: "0x89", name: "Polygon", rpcUrl: "https://polygon-rpc.com/", symbol: "MATIC", explorer: "https://polygonscan.com", icon: "🟣", }, { chainId: "0xa4b1", name: "Arbitrum One", rpcUrl: "https://arb1.arbitrum.io/rpc", symbol: "ETH", explorer: "https://arbiscan.io", icon: "🔵", }, { chainId: "0xa", name: "Optimism", rpcUrl: "https://mainnet.optimism.io", symbol: "ETH", explorer: "https://optimistic.etherscan.io", icon: "🔴", }, { chainId: "0xa86a", name: "Avalanche C-Chain", rpcUrl: "https://api.avax.network/ext/bc/C/rpc", symbol: "AVAX", explorer: "https://snowtrace.io", icon: "🔺", }, ] useEffect(() => { getCurrentNetwork() }, [provider]) const getCurrentNetwork = async () => { try { const chainId = await provider.request({ method: "eth_chainId" }) const network = networks.find((n) => n.chainId === chainId) setCurrentNetwork(network || networks[0]) } catch (error) { console.error("Error getting current network:", error) } } const switchNetwork = async (network: Network) => { setIsSwitching(true) try { await provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: network.chainId }], }) setCurrentNetwork(network) setShowNetworks(false) onNetworkChange?.(network) } catch (error: any) { // If network doesn't exist, add it if (error.code === 4902) { try { await provider.request({ method: "wallet_addEthereumChain", params: [ { chainId: network.chainId, chainName: network.name, nativeCurrency: { name: network.symbol, symbol: network.symbol, decimals: 18, }, rpcUrls: [network.rpcUrl], blockExplorerUrls: [network.explorer], }, ], }) setCurrentNetwork(network) setShowNetworks(false) onNetworkChange?.(network) } catch (addError) { console.error("Error adding network:", addError) } } else { console.error("Error switching network:", error) } } finally { setIsSwitching(false) } } return (

{showNetworks && ( {networks.map((network) => ( ))} )}

) } [V0_FILE]typescriptreact:file="components/message-signer.tsx" isFixed="true" isQuickEdit="true" isMerged="true" "use client" import { useState } from "react" import { Card } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Textarea } from "@/components/ui/textarea" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Copy, Check } from "lucide-react" interface MessageSignerProps { walletAddress: string provider: any } export function MessageSigner({ walletAddress, provider }: MessageSignerProps) { const [message, setMessage] = useState("") const [signature, setSignature] = useState("") const [verifyMessage, setVerifyMessage] = useState("") const [verifySigInput, setVerifySigInput] = useState("") const [verifyAddress, setVerifyAddress] = useState("") const [verifyResult, setVerifyResult] = useState(null) const [isSigning, setIsSigning] = useState(false) const [isVerifying, setIsVerifying] = useState(false) const [copied, setCopied] = useState(false) const signMessage = async () => { if (!message.trim()) { alert("Please enter a message to sign") return } setIsSigning(true) try { const sig = await provider.request({ method: "personal_sign", params: [message, walletAddress], }) setSignature(sig) } catch (error) { console.error("Error signing message:", error) alert("Failed to sign message. Please try again.") } finally { setIsSigning(false) } } const verifySignature = async () => { if (!verifyMessage.trim() || !verifySigInput.trim() || !verifyAddress.trim()) { alert("Please fill in all fields") return } setIsVerifying(true) try { // Simple verification using eth_call (in production, use a proper library) const recovered = await provider.request({ method: "personal_ecRecover", params: [verifyMessage, verifySigInput], }) setVerifyResult(recovered.toLowerCase() === verifyAddress.toLowerCase()) } catch (error) { console.error("Error verifying signature:", error) setVerifyResult(false) } finally { setIsVerifying(false) } } const copyToClipboard = (text: string) => { navigator.clipboard.writeText(text) setCopied(true) setTimeout(() => setCopied(false), 2000) } return (

Message Signing

Sign Message Verify Signature

Message to Sign

setMessage(e.target.value)}
              rows={4}
              className="mt-2"
            />
          </div>

<Button onClick={signMessage} disabled={isSigning || !message.trim()} className="w-full">
            {isSigning ? "Signing..." : "Sign Message"}
          </Button>

{signature && (
            <div className="mt-4 p-4 bg-muted rounded-lg">
              <div className="flex items-center justify-between mb-2">
                <Label>Signature</Label>
                <Button variant="ghost" size="sm" onClick={() => copyToClipboard(signature)} className="h-8 w-8 p-0">
                  {copied ? <Check className="w-4 h-4" /> : <Copy className="w-4 h-4" />}
                </Button>
              </div>
              <p className="text-sm font-mono break-all">{signature}</p>
            </div>
          )}
        </TabsContent>

<TabsContent value="verify" className="space-y-4">
          <div>
            <Label htmlFor="verifyMessage">Original Message</Label>
            <Textarea
              id="verifyMessage"
              placeholder="Enter the original message..."
              value={verifyMessage}
              onChange={(e) => setVerifyMessage(e.target.value)}
              rows={3}
              className="mt-2"
            />
          </div>

<div>
            <Label htmlFor="verifySigInput">Signature</Label>
            <Input
              id="verifySigInput"
              placeholder="0x..."
              value={verifySigInput}
              onChange={(e) => setVerifySigInput(e.target.value)}
              className="mt-2"
            />
          </div>

<div>
            <Label htmlFor="verifyAddress">Signer Address</Label>
            <Input
              id="verifyAddress"
              placeholder="0x..."
              value={verifyAddress}
              onChange={(e) => setVerifyAddress(e.target.value)}
              className="mt-2"
            />
          </div>

<Button onClick={verifySignature} disabled={isVerifying} className="w-full">
            {isVerifying ? "Verifying..." : "Verify Signature"}
          </Button>

{verifyResult !== null && (
            <div
              className={`mt-4 p-4 rounded-lg ${
                verifyResult
                  ? "bg-primary/10 border border-primary/20"
                  : "bg-destructive/10 border border-destructive/20"
              }`}
            >
              <p className={`font-medium ${verifyResult ? "text-primary" : "text-destructive"}`}>
                {verifyResult ? "✓ Signature is valid!" : "✗ Signature is invalid"}
              </p>
            </div>
          )}
        </TabsContent>
      </Tabs>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/footer.tsx" isMerged="true"
import Link from "next/link"

export function Footer() {
  return (
    <footer className="border-t bg-background mt-auto">
      <div className="container mx-auto px-4 py-6">
        <div className="flex flex-col md:flex-row justify-between items-center gap-4">
          <div className="text-sm text-muted-foreground">
            © {new Date().getFullYear()} LinkFiCrypto. All rights reserved.
          </div>
          <nav className="flex flex-wrap justify-center gap-4 md:gap-6 text-sm">
            <Link href="/privacy" className="text-muted-foreground hover:text-foreground transition-colors">
              Privacy Policy
            </Link>
            <Link href="/terms" className="text-muted-foreground hover:text-foreground transition-colors">
              Terms of Service
            </Link>
            <Link href="/cookies" className="text-muted-foreground hover:text-foreground transition-colors">
              Cookie Policy
            </Link>
            <Link href="/accessibility" className="text-muted-foreground hover:text-foreground transition-colors">
              Accessibility
            </Link>
          </nav>
        </div>
      </div>
    </footer>
  )
}
[V0_FILE]typescriptreact:file="app/terms/page.tsx" isMerged="true"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { ArrowLeft } from "lucide-react"

export const metadata = {
  title: "Terms of Service",
  description: "LinkFiCrypto Terms of Service - User agreement and terms of use",
}

export default function TermsPage() {
  return (
    <div className="min-h-screen bg-background">
      <div className="container mx-auto px-4 py-8 max-w-4xl">
        <Link href="/">
          <Button variant="ghost" className="mb-6">
            <ArrowLeft className="mr-2 h-4 w-4" />
            Back to Home
          </Button>
        </Link>

<h1 className="text-4xl font-bold mb-2">Terms of Service</h1>
        <p className="text-muted-foreground mb-8">Last updated: {new Date().toLocaleDateString()}</p>

<div className="prose prose-neutral dark:prose-invert max-w-none space-y-6">
          <section>
            <h2 className="text-2xl font-semibold mb-4">1. Acceptance of Terms</h2>
            <p className="text-muted-foreground leading-relaxed">
              By accessing or using LinkFiCrypto ("Service"), you agree to be bound by these Terms of Service ("Terms").
              If you do not agree to these Terms, do not use our Service. We reserve the right to modify these Terms at
              any time.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">2. Description of Service</h2>
            <p className="text-muted-foreground leading-relaxed">
              LinkFiCrypto is a non-custodial cryptocurrency wallet interface that allows users to connect their Web3
              wallets, send, receive, and swap digital assets. We do not custody, control, or have access to your
              private keys or funds.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">3. Eligibility</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">To use our Service, you must:</p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Be at least 18 years of age</li>
              <li>Have the legal capacity to enter into binding contracts</li>
              <li>Not be prohibited from using the Service under applicable laws</li>
              <li>Comply with all local, state, and federal laws regarding cryptocurrency</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">4. Non-Custodial Nature</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              LinkFiCrypto is a non-custodial service. This means:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>You retain full control and ownership of your private keys</li>
              <li>We cannot access, recover, or reset your private keys or seed phrases</li>
              <li>You are solely responsible for securing your wallet credentials</li>
              <li>We cannot reverse, cancel, or refund transactions</li>
              <li>Lost or stolen private keys cannot be recovered by us</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">5. User Responsibilities</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">You agree to:</p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Maintain the security of your wallet and private keys</li>
              <li>Use the Service in compliance with all applicable laws</li>
              <li>Not use the Service for illegal activities, including money laundering</li>
              <li>Verify all transaction details before confirming</li>
              <li>Pay all applicable blockchain network fees</li>
              <li>Not attempt to hack, disrupt, or compromise the Service</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">6. Risks and Disclaimers</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              Cryptocurrency transactions involve significant risks:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Cryptocurrency values are highly volatile</li>
              <li>Transactions are irreversible once confirmed on the blockchain</li>
              <li>Smart contract interactions may result in loss of funds</li>
              <li>Network congestion may delay transactions</li>
              <li>Regulatory changes may affect cryptocurrency usage</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">7. Limitation of Liability</h2>
            <p className="text-muted-foreground leading-relaxed">
              TO THE MAXIMUM EXTENT PERMITTED BY LAW, LINKFICRYPTO SHALL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
              SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES, INCLUDING LOSS OF PROFITS, DATA, OR CRYPTOCURRENCY, ARISING
              FROM YOUR USE OF THE SERVICE. OUR TOTAL LIABILITY SHALL NOT EXCEED $100 USD.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">8. Indemnification</h2>
            <p className="text-muted-foreground leading-relaxed">
              You agree to indemnify and hold harmless LinkFiCrypto and its affiliates from any claims, damages, or
              expenses arising from your use of the Service, violation of these Terms, or infringement of any rights of
              another party.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">9. Third-Party Services</h2>
            <p className="text-muted-foreground leading-relaxed">
              Our Service may integrate with third-party wallets, exchanges, and blockchain networks. We are not
              responsible for the functionality, security, or policies of these third-party services.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">10. Intellectual Property</h2>
            <p className="text-muted-foreground leading-relaxed">
              All content, trademarks, and intellectual property on LinkFiCrypto are owned by us or our licensors. You
              may not copy, modify, or distribute our content without permission.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">11. Termination</h2>
            <p className="text-muted-foreground leading-relaxed">
              We reserve the right to suspend or terminate your access to the Service at any time for violation of these
              Terms or for any other reason. You may stop using the Service at any time.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">12. Dispute Resolution</h2>
            <p className="text-muted-foreground leading-relaxed">
              Any disputes arising from these Terms shall be resolved through binding arbitration in accordance with the
              rules of the American Arbitration Association. You waive your right to participate in class action
              lawsuits.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">13. Governing Law</h2>
            <p className="text-muted-foreground leading-relaxed">
              These Terms shall be governed by and construed in accordance with the laws of the State of Delaware,
              United States, without regard to its conflict of law provisions.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">14. Contact Information</h2>
            <p className="text-muted-foreground leading-relaxed">
              For questions about these Terms, please contact us at: legal@linkficrypto.com
            </p>
          </section>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/accessibility/page.tsx" isMerged="true"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { ArrowLeft } from "lucide-react"

export const metadata = {
  title: "Accessibility Statement",
  description: "LinkFiCrypto Accessibility Statement - Our commitment to digital accessibility",
}

export default function AccessibilityPage() {
  return (
    <div className="min-h-screen bg-background">
      <div className="container mx-auto px-4 py-8 max-w-4xl">
        <Link href="/">
          <Button variant="ghost" className="mb-6">
            <ArrowLeft className="mr-2 h-4 w-4" />
            Back to Home
          </Button>
        </Link>

<h1 className="text-4xl font-bold mb-2">Accessibility Statement</h1>
        <p className="text-muted-foreground mb-8">Last updated: {new Date().toLocaleDateString()}</p>

<div className="prose prose-neutral dark:prose-invert max-w-none space-y-6">
          <section>
            <h2 className="text-2xl font-semibold mb-4">1. Our Commitment</h2>
            <p className="text-muted-foreground leading-relaxed">
              LinkFiCrypto is committed to ensuring digital accessibility for people with disabilities. We are
              continually improving the user experience for everyone and applying the relevant accessibility standards
              to ensure we provide equal access to all users.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">2. Conformance Status</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We strive to conform to the Web Content Accessibility Guidelines (WCAG) 2.1 Level AA standards. These
              guidelines explain how to make web content more accessible for people with disabilities and user-friendly
              for everyone.
            </p>
            <p className="text-muted-foreground leading-relaxed">
              Our conformance status: Partially conformant - Some parts of the content do not fully conform to WCAG 2.1
              Level AA, but we are actively working to improve accessibility.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">3. Accessibility Features</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              LinkFiCrypto includes the following accessibility features:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Semantic HTML structure for screen reader compatibility</li>
              <li>Keyboard navigation support for all interactive elements</li>
              <li>ARIA labels and roles for enhanced screen reader support</li>
              <li>Sufficient color contrast ratios (WCAG AA compliant)</li>
              <li>Responsive design that works across devices and screen sizes</li>
              <li>Alternative text for images and icons</li>
              <li>Focus indicators for keyboard navigation</li>
              <li>Skip navigation links for screen reader users</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">4. Supported Technologies</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              LinkFiCrypto is designed to work with the following assistive technologies:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Screen readers (JAWS, NVDA, VoiceOver, TalkBack)</li>
              <li>Screen magnification software</li>
              <li>Speech recognition software</li>
              <li>Keyboard-only navigation</li>
              <li>Browser zoom functionality</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">5. Known Limitations</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              Despite our efforts, some limitations may exist:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Third-party wallet interfaces may have their own accessibility limitations</li>
              <li>Some blockchain transaction confirmations may not be fully accessible</li>
              <li>Complex financial data visualizations may be challenging for screen readers</li>
              <li>Real-time price updates may not always announce to screen readers</li>
            </ul>
            <p className="text-muted-foreground leading-relaxed mt-4">
              We are actively working to address these limitations and improve accessibility across all features.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">6. Browser Compatibility</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              LinkFiCrypto is designed to be compatible with the following browsers:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Chrome (latest version)</li>
              <li>Firefox (latest version)</li>
              <li>Safari (latest version)</li>
              <li>Edge (latest version)</li>
              <li>Mobile browsers (iOS Safari, Chrome Mobile)</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">7. Keyboard Navigation</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              You can navigate LinkFiCrypto using keyboard shortcuts:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Tab: Move forward through interactive elements</li>
              <li>Shift + Tab: Move backward through interactive elements</li>
              <li>Enter/Space: Activate buttons and links</li>
              <li>Escape: Close modals and dialogs</li>
              <li>Arrow keys: Navigate within menus and lists</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">8. Text Size and Zoom</h2>
            <p className="text-muted-foreground leading-relaxed">
              You can adjust text size using your browser's zoom functionality (typically Ctrl/Cmd + or -). Our website
              is designed to remain functional and readable at zoom levels up to 200%.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">9. Third-Party Content</h2>
            <p className="text-muted-foreground leading-relaxed">
              Some content on LinkFiCrypto may be provided by third parties (wallet providers, blockchain networks).
              While we strive to ensure all content is accessible, we cannot guarantee the accessibility of third-party
              services.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">10. Feedback and Contact</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We welcome your feedback on the accessibility of LinkFiCrypto. If you encounter accessibility barriers,
              please let us know:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Email: accessibility@linkficrypto.com</li>
              <li>We aim to respond to accessibility feedback within 5 business days</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">11. Ongoing Improvements</h2>
            <p className="text-muted-foreground leading-relaxed">
              We are committed to continuous improvement of our accessibility. Our team regularly reviews and tests the
              website with assistive technologies and conducts accessibility audits to identify and fix issues.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">12. Legal Compliance</h2>
            <p className="text-muted-foreground leading-relaxed">
              LinkFiCrypto strives to comply with the Americans with Disabilities Act (ADA), Section 508 of the
              Rehabilitation Act, and other applicable accessibility laws and regulations.
            </p>
          </section>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/cookie-banner.tsx" isEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { X, Cookie } from "lucide-react"
import Link from "next/link"
import { Button } from "@/components/ui/button"

export function CookieBanner() {
  const [showBanner, setShowBanner] = useState(false)

useEffect(() => {
    console.log("[v0] CookieBanner mounted")

// Check if user has already made a choice
    const cookieConsent = localStorage.getItem("cookie_consent")
    console.log("[v0] Cookie consent value:", cookieConsent)

if (!cookieConsent) {
      console.log("[v0] No cookie consent found, showing banner")
      setShowBanner(true)
    } else {
      console.log("[v0] Cookie consent exists, hiding banner")
    }
  }, [])

const handleAccept = () => {
    console.log("[v0] User accepted cookies")
    localStorage.setItem("cookie_consent", "accepted")
    setShowBanner(false)
  }

const handleDecline = () => {
    console.log("[v0] User declined cookies")
    localStorage.setItem("cookie_consent", "declined")
    setShowBanner(false)
  }

const handleClose = () => {
    console.log("[v0] User closed banner without choosing")
    setShowBanner(false)
  }

console.log("[v0] CookieBanner render - showBanner:", showBanner)

if (!showBanner) return null

return (
    <div className="fixed bottom-0 left-0 right-0 z-50 p-2 md:p-3">
      <div className="mx-auto max-w-6xl rounded-2xl bg-white shadow-2xl border border-gray-200">
        <div className="relative p-3 md:p-4">
          <button
            onClick={handleClose}
            className="absolute top-2 right-2 text-gray-400 hover:text-gray-600 transition-colors"
            aria-label="Close cookie banner"
          >
            <X className="w-4 h-4" />
          </button>

<div className="flex-1">
              <p className="text-xs md:text-sm text-gray-900 mb-1">
                We currently use cookies to improve and customize your experience on our site. If you accept, we'll also
                use marketing cookies to show you personalized ads.{" "}
                <Link href="/cookies" className="text-blue-600 hover:text-blue-700 underline font-medium">
                  Manage your cookies and learn more.
                </Link>
              </p>

<div className="flex flex-col sm:flex-row gap-2 mt-3">
                <Button
                  onClick={handleAccept}
                  variant="outline"
                  className="flex-1 rounded-full border-2 border-gray-300 hover:border-gray-400 hover:bg-gray-50 text-sm py-2 bg-transparent"
                >
                  Yes, I accept
                </Button>
                <Button
                  onClick={handleDecline}
                  variant="outline"
                  className="flex-1 rounded-full border-2 border-gray-300 hover:border-gray-400 hover:bg-gray-50 text-sm py-2 bg-transparent"
                >
                  No, I decline
                </Button>
              </div>
            </div>
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]png:file="public/qr-logo.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0186-IUIsVB9TtR5uDIWT0MLzyZXI6NIsD3.jpeg" isMerged="true"
[V0_FILE]typescriptreact:file="components/receive-interface.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { QrCode, Copy, Check } from "lucide-react"

interface ReceiveInterfaceProps {
  address: string
}

export function ReceiveInterface({ address }: ReceiveInterfaceProps) {
  const [copied, setCopied] = useState(false)

const copyAddress = () => {
    navigator.clipboard.writeText(address)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

return (
    <div className="max-w-lg mx-auto">
      <Card className="p-6 border-border">
        <div className="flex items-center gap-3 mb-6">
          <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
            <QrCode className="w-5 h-5 text-primary" />
          </div>
          <h2 className="text-2xl font-bold text-foreground">Receive</h2>
        </div>

{/* Address */}
          <div className="space-y-2">
            <label className="text-sm font-medium text-foreground">Your Wallet Address</label>
            <div className="flex items-center gap-2 p-4 rounded-lg bg-muted border border-border">
              <span className="text-sm font-mono text-foreground flex-1 break-all">{address}</span>
              <Button variant="ghost" size="sm" onClick={copyAddress} className="h-9 w-9 p-0 flex-shrink-0">
                {copied ? <Check className="w-4 h-4 text-success" /> : <Copy className="w-4 h-4" />}
              </Button>
            </div>
          </div>

{/* Instructions */}
          <div className="p-4 rounded-lg bg-primary/5 border border-primary/20">
            <p className="text-sm text-foreground mb-2 font-medium">How to receive crypto:</p>
            <ol className="text-xs text-muted-foreground space-y-1 list-decimal list-inside">
              <li>Share your wallet address or QR code with the sender</li>
              <li>Wait for the transaction to be confirmed on the blockchain</li>
              <li>Your balance will update automatically</li>
            </ol>
          </div>

{/* Copy Button */}
          <Button onClick={copyAddress} size="lg" className="w-full bg-transparent" variant="outline">
            {copied ? "Copied!" : "Copy Address"}
          </Button>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/network-selector.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { Check, ChevronDown } from "lucide-react"
import { NETWORKS, type Network, switchNetwork, getCurrentNetwork } from "@/lib/networks"

interface NetworkSelectorProps {
  provider: any
  onNetworkChange?: (network: Network) => void
}

export function NetworkSelector({ provider, onNetworkChange }: NetworkSelectorProps) {
  const [currentNetwork, setCurrentNetwork] = useState<Network | null>(null)
  const [isOpen, setIsOpen] = useState(false)
  const [isSwitching, setIsSwitching] = useState(false)

useEffect(() => {
    const loadNetwork = async () => {
      if (!provider) return
      const network = await getCurrentNetwork(provider)
      setCurrentNetwork(network)
    }
    loadNetwork()

// Listen for network changes
    if (provider?.on) {
      const handleChainChanged = async (chainId: string) => {
        const chainIdDecimal = Number.parseInt(chainId, 16)
        const network = Object.values(NETWORKS).find((n) => n.chainId === chainIdDecimal)
        setCurrentNetwork(network || null)
        if (network && onNetworkChange) {
          onNetworkChange(network)
        }
      }
      provider.on("chainChanged", handleChainChanged)
      return () => provider.removeListener("chainChanged", handleChainChanged)
    }
  }, [provider, onNetworkChange])

const handleSwitchNetwork = async (network: Network) => {
    setIsSwitching(true)
    const success = await switchNetwork(provider, network)
    if (success) {
      setCurrentNetwork(network)
      if (onNetworkChange) {
        onNetworkChange(network)
      }
      setIsOpen(false)
    }
    setIsSwitching(false)
  }

if (!currentNetwork) {
    return <div className="px-3 py-2 rounded-lg bg-muted text-muted-foreground text-sm">Unknown Network</div>
  }

return (
    <div className="relative">
      <Button variant="outline" size="sm" onClick={() => setIsOpen(!isOpen)} className="gap-2" disabled={isSwitching}>
        <span style={{ color: currentNetwork.color }}>{currentNetwork.icon}</span>
        <span className="font-semibold">{currentNetwork.name}</span>
        <ChevronDown className="w-4 h-4" />
      </Button>

{isOpen && (
        <>
          <div className="fixed inset-0 z-40" onClick={() => setIsOpen(false)} />
          <Card className="absolute top-full right-0 mt-2 w-64 p-2 z-50 max-h-96 overflow-y-auto">
            <div className="space-y-1">
              {Object.values(NETWORKS).map((network) => (
                <button
                  key={network.id}
                  onClick={() => handleSwitchNetwork(network)}
                  disabled={isSwitching}
                  className={`w-full flex items-center gap-3 p-3 rounded-lg transition-colors ${
                    currentNetwork.id === network.id ? "bg-primary/10 text-primary" : "hover:bg-accent"
                  }`}
                >
                  <span style={{ color: network.color }} className="text-xl">
                    {network.icon}
                  </span>
                  <div className="flex-1 text-left">
                    <p className="font-semibold text-sm">{network.name}</p>
                    <p className="text-xs text-muted-foreground">{network.symbol}</p>
                  </div>
                  {currentNetwork.id === network.id && <Check className="w-4 h-4 text-primary" />}
                </button>
              ))}
            </div>
          </Card>
        </>
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="lib/address-book.ts" isMerged="true"
export interface SavedAddress {
  id: string
  name: string
  address: string
  note?: string
  addedAt: number
  lastUsed?: number
}

const ADDRESS_BOOK_KEY = "linkfi_address_book"

export function getAddressBook(): SavedAddress[] {
  if (typeof window === "undefined") return []

try {
    const stored = localStorage.getItem(ADDRESS_BOOK_KEY)
    return stored ? JSON.parse(stored) : []
  } catch (error) {
    console.error("Error loading address book:", error)
    return []
  }
}

export function saveAddress(name: string, address: string, note?: string): SavedAddress {
  const addressBook = getAddressBook()

// Check if address already exists
  const existing = addressBook.find((a) => a.address.toLowerCase() === address.toLowerCase())
  if (existing) {
    throw new Error("Address already exists in address book")
  }

const newAddress: SavedAddress = {
    id: Date.now().toString(),
    name,
    address,
    note,
    addedAt: Date.now(),
  }

const updated = [newAddress, ...addressBook]
  localStorage.setItem(ADDRESS_BOOK_KEY, JSON.stringify(updated))

return newAddress
}

export function updateAddress(id: string, updates: Partial<SavedAddress>): void {
  const addressBook = getAddressBook()
  const index = addressBook.findIndex((a) => a.id === id)

if (index === -1) {
    throw new Error("Address not found")
  }

addressBook[index] = { ...addressBook[index], ...updates }
  localStorage.setItem(ADDRESS_BOOK_KEY, JSON.stringify(addressBook))
}

export function deleteAddress(id: string): void {
  const addressBook = getAddressBook()
  const filtered = addressBook.filter((a) => a.id !== id)
  localStorage.setItem(ADDRESS_BOOK_KEY, JSON.stringify(filtered))
}

export function updateLastUsed(address: string): void {
  const addressBook = getAddressBook()
  const found = addressBook.find((a) => a.address.toLowerCase() === address.toLowerCase())

if (found) {
    found.lastUsed = Date.now()
    localStorage.setItem(ADDRESS_BOOK_KEY, JSON.stringify(addressBook))
  }
}

export function searchAddresses(query: string): SavedAddress[] {
  const addressBook = getAddressBook()
  const lowerQuery = query.toLowerCase()

return addressBook.filter(
    (a) =>
      a.name.toLowerCase().includes(lowerQuery) ||
      a.address.toLowerCase().includes(lowerQuery) ||
      a.note?.toLowerCase().includes(lowerQuery),
  )
}
[V0_FILE]typescriptreact:file="components/address-book-modal.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { X, Plus, Edit2, Trash2, Search, BookUser, Check } from "lucide-react"
import { getAddressBook, saveAddress, updateAddress, deleteAddress, type SavedAddress } from "@/lib/address-book"

interface AddressBookModalProps {
  onClose: () => void
  onSelectAddress: (address: string) => void
}

export function AddressBookModal({ onClose, onSelectAddress }: AddressBookModalProps) {
  const [addresses, setAddresses] = useState<SavedAddress[]>([])
  const [searchQuery, setSearchQuery] = useState("")
  const [showAddForm, setShowAddForm] = useState(false)
  const [editingId, setEditingId] = useState<string | null>(null)
  const [formData, setFormData] = useState({ name: "", address: "", note: "" })
  const [error, setError] = useState("")

useEffect(() => {
    loadAddresses()
  }, [])

const loadAddresses = () => {
    const book = getAddressBook()
    setAddresses(book)
  }

const filteredAddresses = searchQuery
    ? addresses.filter(
        (a) =>
          a.name.toLowerCase().includes(searchQuery.toLowerCase()) ||
          a.address.toLowerCase().includes(searchQuery.toLowerCase()) ||
          a.note?.toLowerCase().includes(searchQuery.toLowerCase()),
      )
    : addresses

const handleSave = () => {
    setError("")
    try {
      if (!formData.name.trim()) {
        setError("Name is required")
        return
      }
      if (!formData.address.trim() || !formData.address.startsWith("0x")) {
        setError("Valid Ethereum address is required")
        return
      }

if (editingId) {
        updateAddress(editingId, formData)
      } else {
        saveAddress(formData.name, formData.address, formData.note)
      }

setFormData({ name: "", address: "", note: "" })
      setShowAddForm(false)
      setEditingId(null)
      loadAddresses()
    } catch (err: any) {
      setError(err.message)
    }
  }

const handleEdit = (addr: SavedAddress) => {
    setFormData({ name: addr.name, address: addr.address, note: addr.note || "" })
    setEditingId(addr.id)
    setShowAddForm(true)
  }

const handleDelete = (id: string) => {
    if (confirm("Are you sure you want to delete this address?")) {
      deleteAddress(id)
      loadAddresses()
    }
  }

const handleSelect = (address: string) => {
    onSelectAddress(address)
    onClose()
  }

return (
    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50 p-4">
      <Card className="w-full max-w-2xl max-h-[80vh] overflow-hidden bg-card border-border flex flex-col">
        <div className="p-6 border-b border-border">
          <div className="flex items-center justify-between mb-4">
            <div className="flex items-center gap-3">
              <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
                <BookUser className="w-5 h-5 text-primary" />
              </div>
              <h2 className="text-2xl font-bold text-foreground">Address Book</h2>
            </div>
            <Button variant="ghost" size="icon" onClick={onClose}>
              <X className="w-5 h-5" />
            </Button>
          </div>

<div className="flex gap-2">
            <div className="relative flex-1">
              <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
              <Input
                placeholder="Search addresses..."
                value={searchQuery}
                onChange={(e) => setSearchQuery(e.target.value)}
                className="pl-10"
              />
            </div>
            <Button onClick={() => setShowAddForm(!showAddForm)}>
              <Plus className="w-4 h-4 mr-2" />
              Add
            </Button>
          </div>
        </div>

{showAddForm && (
          <div className="p-6 border-b border-border bg-accent/50">
            <h3 className="text-lg font-semibold mb-4">{editingId ? "Edit" : "Add New"} Address</h3>
            <div className="space-y-3">
              <div>
                <label className="text-sm font-medium text-foreground mb-1 block">Name</label>
                <Input
                  placeholder="e.g., Alice, Exchange Wallet"
                  value={formData.name}
                  onChange={(e) => setFormData({ ...formData, name: e.target.value })}
                />
              </div>
              <div>
                <label className="text-sm font-medium text-foreground mb-1 block">Address</label>
                <Input
                  placeholder="0x..."
                  value={formData.address}
                  onChange={(e) => setFormData({ ...formData, address: e.target.value })}
                  className="font-mono"
                />
              </div>
              <div>
                <label className="text-sm font-medium text-foreground mb-1 block">Note (optional)</label>
                <Input
                  placeholder="Add a note..."
                  value={formData.note}
                  onChange={(e) => setFormData({ ...formData, note: e.target.value })}
                />
              </div>
              {error && (
                <div className="p-3 rounded-lg bg-destructive/10 border border-destructive/20">
                  <p className="text-sm text-destructive">{error}</p>
                </div>
              )}
              <div className="flex gap-2">
                <Button onClick={handleSave} className="flex-1">
                  <Check className="w-4 h-4 mr-2" />
                  Save
                </Button>
                <Button
                  variant="outline"
                  onClick={() => {
                    setShowAddForm(false)
                    setEditingId(null)
                    setFormData({ name: "", address: "", note: "" })
                    setError("")
                  }}
                  className="flex-1"
                >
                  Cancel
                </Button>
              </div>
            </div>
          </div>
        )}

<div className="flex-1 overflow-y-auto p-6">
          {filteredAddresses.length === 0 ? (
            <div className="text-center py-12">
              <BookUser className="w-12 h-12 text-muted-foreground mx-auto mb-3 opacity-50" />
              <p className="text-muted-foreground mb-1">{searchQuery ? "No addresses found" : "No saved addresses"}</p>
              <p className="text-sm text-muted-foreground">
                {searchQuery ? "Try a different search" : "Add addresses to quickly access them later"}
              </p>
            </div>
          ) : (
            <div className="space-y-2">
              {filteredAddresses.map((addr) => (
                <Card key={addr.id} className="p-4 border-border hover:border-primary/50 transition-colors">
                  <div className="flex items-start justify-between gap-3">
                    <button onClick={() => handleSelect(addr.address)} className="flex-1 text-left">
                      <div className="flex items-center gap-2 mb-1">
                        <h3 className="font-semibold text-foreground">{addr.name}</h3>
                        {addr.lastUsed && (
                          <span className="text-xs px-2 py-0.5 rounded-full bg-primary/10 text-primary">
                            Recently used
                          </span>
                        )}
                      </div>
                      <p className="text-sm font-mono text-muted-foreground mb-1">{addr.address}</p>
                      {addr.note && <p className="text-xs text-muted-foreground">{addr.note}</p>}
                    </button>
                    <div className="flex gap-1">
                      <Button variant="ghost" size="icon" onClick={() => handleEdit(addr)} className="h-8 w-8">
                        <Edit2 className="w-4 h-4" />
                      </Button>
                      <Button
                        variant="ghost"
                        size="icon"
                        onClick={() => handleDelete(addr.id)}
                        className="h-8 w-8 hover:bg-destructive/10"
                      >
                        <Trash2 className="w-4 h-4 text-destructive" />
                      </Button>
                    </div>
                  </div>
                </Card>
              ))}
            </div>
          )}
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="lib/dex-aggregator.ts" isMerged="true"
export interface TokenInfo {
  address: string
  symbol: string
  decimals: number
  logoURI?: string
}

export interface SwapQuote {
  dex: string
  fromToken: string
  toToken: string
  fromAmount: string
  toAmount: string
  estimatedGas: string
  priceImpact: number
  route: string[]
}

export interface AggregatedQuote {
  bestQuote: SwapQuote
  allQuotes: SwapQuote[]
  savings: string
}

// Popular token addresses on Ethereum mainnet
export const POPULAR_TOKENS: Record<string, TokenInfo> = {
  ETH: {
    address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    symbol: "ETH",
    decimals: 18,
  },
  USDC: {
    address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    symbol: "USDC",
    decimals: 6,
  },
  USDT: {
    address: "0xdac17f958d2ee523a2206206994597c13d831ec7",
    symbol: "USDT",
    decimals: 6,
  },
  DAI: {
    address: "0x6b175474e89094c44da98b954eedeac495271d0f",
    symbol: "DAI",
    decimals: 18,
  },
  WBTC: {
    address: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
    symbol: "WBTC",
    decimals: 8,
  },
}

// Simulated DEX quotes - in production, use actual DEX aggregator APIs
export async function getAggregatedQuotes(
  fromToken: string,
  toToken: string,
  amount: string,
  chainId = 1,
): Promise<AggregatedQuote> {
  // Simulate API call delay
  await new Promise((resolve) => setTimeout(resolve, 1000))

const fromAmount = Number.parseFloat(amount)
  if (isNaN(fromAmount) || fromAmount <= 0) {
    throw new Error("Invalid amount")
  }

// Simulated quotes from different DEXs
  const baseRate = 3200 // 1 ETH = 3200 USDC

const quotes: SwapQuote[] = [
    {
      dex: "1inch",
      fromToken,
      toToken,
      fromAmount: amount,
      toAmount: (fromAmount * baseRate * 1.002).toFixed(2), // Best rate
      estimatedGas: "150000",
      priceImpact: 0.1,
      route: [fromToken, toToken],
    },
    {
      dex: "Uniswap V3",
      fromToken,
      toToken,
      fromAmount: amount,
      toAmount: (fromAmount * baseRate * 1.001).toFixed(2),
      estimatedGas: "180000",
      priceImpact: 0.15,
      route: [fromToken, toToken],
    },
    {
      dex: "Uniswap V2",
      fromToken,
      toToken,
      fromAmount: amount,
      toAmount: (fromAmount * baseRate * 0.998).toFixed(2),
      estimatedGas: "160000",
      priceImpact: 0.2,
      route: [fromToken, toToken],
    },
    {
      dex: "SushiSwap",
      fromToken,
      toToken,
      fromAmount: amount,
      toAmount: (fromAmount * baseRate * 0.997).toFixed(2),
      estimatedGas: "165000",
      priceImpact: 0.18,
      route: [fromToken, toToken],
    },
    {
      dex: "Curve",
      fromToken,
      toToken,
      fromAmount: amount,
      toAmount: (fromAmount * baseRate * 0.999).toFixed(2),
      estimatedGas: "200000",
      priceImpact: 0.12,
      route: [fromToken, "DAI", toToken],
    },
  ]

// Sort by best rate (highest toAmount)
  quotes.sort((a, b) => Number.parseFloat(b.toAmount) - Number.parseFloat(a.toAmount))

const bestQuote = quotes[0]
  const secondBest = quotes[1]
  const savings = (Number.parseFloat(bestQuote.toAmount) - Number.parseFloat(secondBest.toAmount)).toFixed(2)

return {
    bestQuote,
    allQuotes: quotes,
    savings,
  }
}

export function calculatePriceImpact(fromAmount: string, toAmount: string, marketRate: number): number {
  const from = Number.parseFloat(fromAmount)
  const to = Number.parseFloat(toAmount)
  const expectedTo = from * marketRate
  return ((expectedTo - to) / expectedTo) * 100
}

export function formatGasEstimate(gas: string): string {
  const gasAmount = Number.parseInt(gas)
  if (gasAmount < 100000) return `${(gasAmount / 1000).toFixed(0)}K`
  return `${(gasAmount / 1000).toFixed(0)}K`
}
[V0_FILE]typescriptreact:file="components/swap-interface.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useMemo, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { ArrowDownUp, Settings, Info, ChevronDown, TrendingUp, Zap, RefreshCw } from "lucide-react"
import { getAggregatedQuotes, formatGasEstimate, type AggregatedQuote } from "@/lib/dex-aggregator"
import { RiskDisclaimer } from "@/components/risk-disclaimer"

interface SwapInterfaceProps {
  address: string
}

const ONEINCH_AFFILIATE_URL = "https://app.1inch.io/#/1/simple/swap?ref=0x977967e0B4aF4fD746e65572461cb6a1F191dDd2"
const PLATFORM_FEE_PERCENT = 0.5

export function SwapInterface({ address }: SwapInterfaceProps) {
  const [fromAmount, setFromAmount] = useState("")
  const [toAmount, setToAmount] = useState("")
  const [fromToken, setFromToken] = useState("ETH")
  const [toToken, setToToken] = useState("USDC")
  const [quotes, setQuotes] = useState<AggregatedQuote | null>(null)
  const [isLoadingQuotes, setIsLoadingQuotes] = useState(false)
  const [showAllRoutes, setShowAllRoutes] = useState(false)

useEffect(() => {
    if (fromAmount && Number.parseFloat(fromAmount) > 0) {
      fetchQuotes()
    } else {
      setQuotes(null)
      setToAmount("")
    }
  }, [fromAmount, fromToken, toToken])

const fetchQuotes = async () => {
    setIsLoadingQuotes(true)
    try {
      const aggregated = await getAggregatedQuotes(fromToken, toToken, fromAmount)
      setQuotes(aggregated)
      setToAmount(aggregated.bestQuote.toAmount)
    } catch (error) {
      console.error("Error fetching quotes:", error)
    } finally {
      setIsLoadingQuotes(false)
    }
  }

const feeCalculation = useMemo(() => {
    const amount = Number.parseFloat(fromAmount) || 0
    const platformFee = amount * (PLATFORM_FEE_PERCENT / 100)
    const youReceive = amount - platformFee

return {
      platformFee: platformFee.toFixed(6),
      youReceive: youReceive.toFixed(6),
      hasFee: amount > 0,
    }
  }, [fromAmount])

const handleSwapDirection = () => {
    setFromToken(toToken)
    setToToken(fromToken)
    setFromAmount(toAmount)
    setToAmount(fromAmount)
    setQuotes(null)
  }

const openOneInchSwap = () => {
    const url = new URL(ONEINCH_AFFILIATE_URL)
    if (fromToken) url.searchParams.set("from", fromToken)
    if (toToken) url.searchParams.set("to", toToken)
    if (fromAmount) url.searchParams.set("amount", fromAmount)
    window.open(url.toString(), "_blank", "noopener,noreferrer")
  }

return (
    <div className="max-w-lg mx-auto">
      <div className="mb-4">
        <RiskDisclaimer context="swap" />
      </div>

<div className="space-y-2 mb-2">
          <label className="text-sm text-muted-foreground">From</label>
          <div className="relative">
            <Input
              type="number"
              placeholder="0.0"
              value={fromAmount}
              onChange={(e) => setFromAmount(e.target.value)}
              className="text-2xl h-16 pr-24 font-semibold"
            />
            <div className="absolute right-3 top-1/2 -translate-y-1/2">
              <div className="px-3 py-1.5 rounded-lg bg-muted font-medium text-sm">{fromToken}</div>
            </div>
          </div>
          <p className="text-xs text-muted-foreground">Balance: 0.0000</p>
        </div>

<div className="space-y-2 mb-6">
          <label className="text-sm text-muted-foreground">To</label>
          <div className="relative">
            <Input
              type="number"
              placeholder="0.0"
              value={toAmount}
              readOnly
              className="text-2xl h-16 pr-24 font-semibold bg-muted/50"
            />
            <div className="absolute right-3 top-1/2 -translate-y-1/2">
              <div className="px-3 py-1.5 rounded-lg bg-muted font-medium text-sm">{toToken}</div>
            </div>
          </div>
          {isLoadingQuotes && (
            <p className="text-xs text-muted-foreground flex items-center gap-2">
              <RefreshCw className="w-3 h-3 animate-spin" />
              Finding best rates...
            </p>
          )}
          {quotes && !isLoadingQuotes && (
            <p className="text-xs text-success flex items-center gap-1">
              <Zap className="w-3 h-3" />
              Best rate via {quotes.bestQuote.dex} • Save ${quotes.savings}
            </p>
          )}
        </div>

{quotes && (
          <div className="mb-4 space-y-3">
            <Card className="p-4 border-primary/30 bg-primary/5">
              <div className="flex items-center justify-between mb-3">
                <div className="flex items-center gap-2">
                  <div className="w-8 h-8 rounded-full bg-primary/20 flex items-center justify-center">
                    <Zap className="w-4 h-4 text-primary" />
                  </div>
                  <div>
                    <p className="text-sm font-semibold text-foreground">Best Rate: {quotes.bestQuote.dex}</p>
                    <p className="text-xs text-muted-foreground">
                      Gas: {formatGasEstimate(quotes.bestQuote.estimatedGas)} • Impact: {quotes.bestQuote.priceImpact}%
                    </p>
                  </div>
                </div>
                <TrendingUp className="w-5 h-5 text-success" />
              </div>

<div className="space-y-1 text-sm">
                <div className="flex justify-between">
                  <span className="text-muted-foreground">You get</span>
                  <span className="text-foreground font-semibold">
                    {quotes.bestQuote.toAmount} {toToken}
                  </span>
                </div>
                <div className="flex justify-between">
                  <span className="text-muted-foreground">Savings vs 2nd best</span>
                  <span className="text-success font-medium">+${quotes.savings}</span>
                </div>
              </div>
            </Card>

<button
              onClick={() => setShowAllRoutes(!showAllRoutes)}
              className="w-full flex items-center justify-between text-sm text-muted-foreground hover:text-foreground transition-colors"
            >
              <span>Compare all routes ({quotes.allQuotes.length})</span>
              <ChevronDown className={`w-4 h-4 transition-transform ${showAllRoutes ? "rotate-180" : ""}`} />
            </button>

{showAllRoutes && (
              <div className="space-y-2">
                {quotes.allQuotes.map((quote, index) => (
                  <Card
                    key={index}
                    className={`p-3 border ${index === 0 ? "border-primary/50 bg-primary/5" : "border-border"}`}
                  >
                    <div className="flex items-center justify-between">
                      <div>
                        <p className="text-sm font-medium text-foreground">{quote.dex}</p>
                        <p className="text-xs text-muted-foreground">
                          Gas: {formatGasEstimate(quote.estimatedGas)} • {quote.priceImpact}% impact
                        </p>
                      </div>
                      <div className="text-right">
                        <p className="text-sm font-semibold text-foreground">{quote.toAmount}</p>
                        <p className="text-xs text-muted-foreground">{toToken}</p>
                      </div>
                    </div>
                  </Card>
                ))}
              </div>
            )}
          </div>
        )}

{feeCalculation.hasFee && (
          <div className="mb-4 p-4 rounded-lg bg-amber-50 dark:bg-amber-950/20 border border-amber-200 dark:border-amber-800/30">
            <div className="space-y-2">
              <div className="flex justify-between items-center text-sm">
                <span className="text-muted-foreground">Platform Fee ({PLATFORM_FEE_PERCENT}%)</span>
                <span className="text-amber-600 dark:text-amber-500 font-medium">
                  {feeCalculation.platformFee} {fromToken}
                </span>
              </div>
            </div>
          </div>
        )}

<div className="mb-6 p-4 rounded-lg bg-blue-500/5 border border-blue-500/20">
          <div className="flex items-start gap-2">
            <Info className="w-4 h-4 text-blue-600 mt-0.5 flex-shrink-0" />
            <div className="text-xs text-foreground">
              <p className="font-medium mb-1">Best Rates Guaranteed</p>
              <p className="text-muted-foreground">
                We compare quotes from 5+ DEXs in real-time to ensure you get the best possible rate for your swap.
              </p>
            </div>
          </div>
        </div>

<Button
          onClick={openOneInchSwap}
          size="lg"
          className="w-full"
          disabled={!fromAmount || Number.parseFloat(fromAmount) <= 0 || isLoadingQuotes}
        >
          {isLoadingQuotes ? "Finding Best Rate..." : "Continue to Swap"}
        </Button>

<div className="mt-6 pt-6 border-t border-border space-y-2">
          {quotes && (
            <>
              <div className="flex justify-between text-sm">
                <span className="text-muted-foreground">Rate</span>
                <span className="text-foreground font-medium">
                  1 {fromToken} ={" "}
                  {(
                    Number.parseFloat(quotes.bestQuote.toAmount) / Number.parseFloat(quotes.bestQuote.fromAmount)
                  ).toFixed(2)}{" "}
                  {toToken}
                </span>
              </div>
              <div className="flex justify-between text-sm">
                <span className="text-muted-foreground">Price Impact</span>
                <span className={`font-medium ${quotes.bestQuote.priceImpact > 1 ? "text-amber-600" : "text-success"}`}>
                  {quotes.bestQuote.priceImpact}%
                </span>
              </div>
            </>
          )}
          <div className="flex justify-between text-sm">
            <span className="text-muted-foreground">Platform Fee</span>
            <span className="text-foreground font-medium">{PLATFORM_FEE_PERCENT}%</span>
          </div>
          <div className="flex justify-between text-sm">
            <span className="text-muted-foreground">Network</span>
            <span className="text-foreground font-medium">Ethereum</span>
          </div>
        </div>
      </Card>

<div className="grid md:grid-cols-3 gap-4 mt-6">
        <Card className="p-4 border-border">
          <h4 className="font-semibold text-sm text-foreground mb-2">Best Rates</h4>
          <p className="text-xs text-muted-foreground">Auto-routes through 5+ DEXs for optimal pricing</p>
        </Card>
        <Card className="p-4 border-border">
          <h4 className="font-semibold text-sm text-foreground mb-2">Real-Time Quotes</h4>
          <p className="text-xs text-muted-foreground">Live price comparison across all major DEXs</p>
        </Card>
        <Card className="p-4 border-border">
          <h4 className="font-semibold text-sm text-foreground mb-2">Low Fees</h4>
          <p className="text-xs text-muted-foreground">
            Only {PLATFORM_FEE_PERCENT}% platform fee with transparent pricing
          </p>
        </Card>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/add-money-interface.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { DollarSign, CreditCard, Building2, Smartphone, ExternalLink, Info } from "lucide-react"
import { RiskDisclaimer } from "@/components/risk-disclaimer"

interface AddMoneyInterfaceProps {
  address: string
}

export function AddMoneyInterface({ address }: AddMoneyInterfaceProps) {
  const openMoonPay = () => {
    const moonpayUrl = new URL("https://buy.moonpay.com")
    moonpayUrl.searchParams.append("walletAddress", address)
    moonpayUrl.searchParams.append("colorCode", "#000000")
    moonpayUrl.searchParams.append("defaultCurrencyCode", "eth")
    moonpayUrl.searchParams.append("theme", "dark")

window.open(moonpayUrl.toString(), "_blank", "width=500,height=700")
  }

return (
    <div className="space-y-6">
      <RiskDisclaimer context="addmoney" />

<Card className="p-6 border-border bg-gradient-to-br from-primary/5 to-success/5">
        <div className="flex items-start gap-4">
          <div className="w-12 h-12 rounded-full bg-primary/10 flex items-center justify-center flex-shrink-0">
            <DollarSign className="w-6 h-6 text-primary" />
          </div>
          <div>
            <h2 className="text-2xl font-bold text-foreground mb-2">Add Money to Your Wallet</h2>
            <p className="text-sm text-muted-foreground">
              Buy cryptocurrency using your credit/debit card, bank transfer, or other payment methods. Your crypto will
              be sent directly to your wallet.
            </p>
          </div>
        </div>
      </Card>

<div className="space-y-4">
        <Card className="p-6 border-2 border-primary/50 bg-primary/5 hover:border-primary transition-all cursor-pointer group">
          <div className="flex items-start justify-between mb-4">
            <div>
              <div className="flex items-center gap-2 mb-1">
                <h3 className="text-xl font-bold text-foreground">MoonPay</h3>
              </div>
              <p className="text-sm text-muted-foreground">Trusted by millions worldwide</p>
            </div>
            <div className="w-12 h-12 rounded-full bg-primary/10 flex items-center justify-center">
              <span className="text-2xl">🌙</span>
            </div>
          </div>

<div className="space-y-3 mb-4">
            <div className="flex items-center gap-2 text-sm text-muted-foreground">
              <CreditCard className="w-4 h-4" />
              <span>Credit/Debit Card, Apple Pay, Google Pay</span>
            </div>
            <div className="flex items-center gap-2 text-sm text-muted-foreground">
              <Building2 className="w-4 h-4" />
              <span>Bank Transfer (ACH, SEPA, Faster Payments)</span>
            </div>
            <div className="flex items-center gap-2 text-sm text-muted-foreground">
              <Smartphone className="w-4 h-4" />
              <span>160+ countries supported</span>
            </div>
          </div>

<div className="flex items-center justify-between pt-4 border-t border-border">
            <div className="text-sm">
              <p className="text-muted-foreground">Fee</p>
              <p className="font-semibold text-foreground">~4.5%</p>
            </div>
            <div className="text-sm">
              <p className="text-muted-foreground">Min Amount</p>
              <p className="font-semibold text-foreground">$20</p>
            </div>
            <div className="text-sm">
              <p className="text-muted-foreground">Speed</p>
              <p className="font-semibold text-foreground">5-10 min</p>
            </div>
          </div>

<Button onClick={openMoonPay} className="w-full mt-4">
            Buy with MoonPay
            <ExternalLink className="w-4 h-4 ml-2" />
          </Button>
        </Card>
      </div>

<Card className="p-4 border-border bg-muted/50">
        <div className="flex items-start gap-3">
          <Info className="w-5 h-5 text-primary flex-shrink-0 mt-0.5" />
          <div className="space-y-2 text-sm text-muted-foreground">
            <p>
              <strong className="text-foreground">How it works:</strong> You'll be redirected to MoonPay's secure
              payment platform where you can complete your purchase. The cryptocurrency will be sent directly to your
              connected wallet address.
            </p>
            <p>
              <strong className="text-foreground">Your wallet address:</strong>
              <span className="font-mono text-xs ml-2 text-foreground">
                {address.slice(0, 10)}...{address.slice(-8)}
              </span>
            </p>
            <p>
              <strong className="text-foreground">Important:</strong> You may need to complete identity verification
              (KYC) as required by financial regulations. This is a one-time process that typically takes less than 5
              minutes.
            </p>
          </div>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="lib/referral.ts" isMerged="true"
export interface ReferralData {
  code: string
  referrer: string
  clicks: number
  signups: number
  createdAt: number
}

export interface UserReferralStats {
  myCode: string
  totalReferrals: number
  totalRewards: number
  referralsList: Array<{
    address: string
    joinedAt: number
    status: "pending" | "active"
  }>
}

export function generateReferralCode(address: string): string {
  const short = address.slice(2, 8).toUpperCase()
  return `LFC${short}`
}

export function getReferralLink(code: string): string {
  if (typeof window === "undefined") return `https://linkficrypto.com?ref=${code}`
  return `${window.location.origin}?ref=${code}`
}

export function saveReferralCode(code: string, address: string): void {
  if (typeof window === "undefined") return

try {
    const data: ReferralData = {
      code,
      referrer: address,
      clicks: 0,
      signups: 0,
      createdAt: Date.now(),
    }

localStorage.setItem(`referral_${code}`, JSON.stringify(data))
    localStorage.setItem(`referral_user_${address}`, code)
  } catch (error) {
    console.error("Error saving referral code:", error)
  }
}

export function getReferralData(code: string): ReferralData | null {
  if (typeof window === "undefined") return null

try {
    const data = localStorage.getItem(`referral_${code}`)
    return data ? JSON.parse(data) : null
  } catch (error) {
    console.error("Error getting referral data:", error)
    return null
  }
}

export function trackReferralClick(code: string): void {
  if (typeof window === "undefined") return

try {
    const data = getReferralData(code)
    if (data) {
      data.clicks++
      localStorage.setItem(`referral_${code}`, JSON.stringify(data))
    }
  } catch (error) {
    console.error("Error tracking referral click:", error)
  }
}

export function trackReferralSignup(code: string, newUserAddress: string): void {
  if (typeof window === "undefined") return

try {
    const data = getReferralData(code)
    if (data) {
      data.signups++
      localStorage.setItem(`referral_${code}`, JSON.stringify(data))

// Save that this user was referred
      localStorage.setItem(`user_referred_by_${newUserAddress}`, code)
    }
  } catch (error) {
    console.error("Error tracking referral signup:", error)
  }
}

export function getUserReferralStats(address: string): UserReferralStats {
  if (typeof window === "undefined") {
    return {
      myCode: "",
      totalReferrals: 0,
      totalRewards: 0,
      referralsList: [],
    }
  }

try {
    const code = localStorage.getItem(`referral_user_${address}`) || generateReferralCode(address)
    const data = getReferralData(code)

return {
      myCode: code,
      totalReferrals: data?.signups || 0,
      totalRewards: (data?.signups || 0) * 5, // $5 per referral
      referralsList: [],
    }
  } catch (error) {
    console.error("Error getting user referral stats:", error)
    return {
      myCode: "",
      totalReferrals: 0,
      totalRewards: 0,
      referralsList: [],
    }
  }
}

export function checkAndTrackReferral(): string | null {
  if (typeof window === "undefined") return null

try {
    const params = new URLSearchParams(window.location.search)
    const refCode = params.get("ref")

if (refCode) {
      // Track the click
      trackReferralClick(refCode)
      // Store in session to track signup later
      sessionStorage.setItem("pending_referral", refCode)
      return refCode
    }

return null
  } catch (error) {
    console.error("Error checking referral:", error)
    return null
  }
}
[V0_FILE]typescriptreact:file="components/referral-interface.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Copy, Check, Share2, Gift, Users, DollarSign } from "lucide-react"
import {
  generateReferralCode,
  getReferralLink,
  saveReferralCode,
  getUserReferralStats,
  type UserReferralStats,
} from "@/lib/referral"

interface ReferralInterfaceProps {
  address: string
}

export function ReferralInterface({ address }: ReferralInterfaceProps) {
  const [stats, setStats] = useState<UserReferralStats>({
    myCode: "",
    totalReferrals: 0,
    totalRewards: 0,
    referralsList: [],
  })
  const [copied, setCopied] = useState(false)

useEffect(() => {
    if (!address) return

const code = generateReferralCode(address)
    saveReferralCode(code, address)

const userStats = getUserReferralStats(address)
    setStats(userStats)
  }, [address])

const referralLink = getReferralLink(stats.myCode)

const handleCopy = async () => {
    try {
      await navigator.clipboard.writeText(referralLink)
      setCopied(true)
      setTimeout(() => setCopied(false), 2000)
    } catch (error) {
      console.error("Failed to copy:", error)
    }
  }

const handleShare = async () => {
    const shareData = {
      title: "Join LinkFiCrypto",
      text: `Use my referral code ${stats.myCode} to get started with LinkFiCrypto - the best non-custodial crypto wallet!`,
      url: referralLink,
    }

if (navigator.share) {
      try {
        await navigator.share(shareData)
      } catch (error) {
        console.log("Share cancelled")
      }
    } else {
      handleCopy()
    }
  }

return (
    <div className="space-y-4">
      <Card className="p-6 bg-gradient-to-br from-primary/10 to-primary/5 border-primary/20">
        <div className="flex items-center gap-3 mb-4">
          <div className="p-3 bg-primary/20 rounded-lg">
            <Gift className="w-6 h-6 text-primary" />
          </div>
          <div>
            <h2 className="text-xl font-bold">Refer & Earn</h2>
            <p className="text-sm text-muted-foreground">Get $5 for every friend who joins</p>
          </div>
        </div>

<div className="grid grid-cols-1 sm:grid-cols-3 gap-4 mb-6">
          <div className="bg-background/50 rounded-lg p-4 text-center">
            <Users className="w-5 h-5 text-primary mx-auto mb-2" />
            <div className="text-2xl font-bold">{stats.totalReferrals}</div>
            <div className="text-xs text-muted-foreground">Referrals</div>
          </div>
          <div className="bg-background/50 rounded-lg p-4 text-center">
            <DollarSign className="w-5 h-5 text-green-500 mx-auto mb-2" />
            <div className="text-2xl font-bold">${stats.totalRewards}</div>
            <div className="text-xs text-muted-foreground">Earned</div>
          </div>
          <div className="bg-background/50 rounded-lg p-4 text-center">
            <Gift className="w-5 h-5 text-primary mx-auto mb-2" />
            <div className="text-2xl font-bold">$5</div>
            <div className="text-xs text-muted-foreground">Per Referral</div>
          </div>
        </div>

<div className="space-y-3">
          <div>
            <label className="text-sm font-medium mb-2 block">Your Referral Code</label>
            <div className="flex gap-2">
              <Input value={stats.myCode} readOnly className="font-mono text-lg" />
              <Button onClick={handleCopy} variant="outline" size="icon">
                {copied ? <Check className="w-4 h-4 text-green-500" /> : <Copy className="w-4 h-4" />}
              </Button>
            </div>
          </div>

<div>
            <label className="text-sm font-medium mb-2 block">Your Referral Link</label>
            <div className="flex gap-2">
              <Input value={referralLink} readOnly className="text-sm" />
              <Button onClick={handleCopy} variant="outline" size="icon">
                {copied ? <Check className="w-4 h-4 text-green-500" /> : <Copy className="w-4 h-4" />}
              </Button>
            </div>
          </div>

<Button onClick={handleShare} className="w-full" size="lg">
            <Share2 className="w-4 h-4 mr-2" />
            Share Referral Link
          </Button>
        </div>
      </Card>

<Card className="p-6">
        <h3 className="font-semibold mb-4">How It Works</h3>
        <div className="space-y-4">
          <div className="flex gap-3">
            <div className="flex-shrink-0 w-8 h-8 rounded-full bg-primary/20 flex items-center justify-center text-primary font-bold">
              1
            </div>
            <div>
              <div className="font-medium">Share Your Link</div>
              <div className="text-sm text-muted-foreground">
                Send your unique referral link to friends via social media or messaging
              </div>
            </div>
          </div>
          <div className="flex gap-3">
            <div className="flex-shrink-0 w-8 h-8 rounded-full bg-primary/20 flex items-center justify-center text-primary font-bold">
              2
            </div>
            <div>
              <div className="font-medium">Friend Connects Wallet</div>
              <div className="text-sm text-muted-foreground">
                Your friend clicks your link and connects their crypto wallet
              </div>
            </div>
          </div>
          <div className="flex gap-3">
            <div className="flex-shrink-0 w-8 h-8 rounded-full bg-primary/20 flex items-center justify-center text-primary font-bold">
              3
            </div>
            <div>
              <div className="font-medium">Both Earn Rewards</div>
              <div className="text-sm text-muted-foreground">You get $5, and your friend gets a bonus too!</div>
            </div>
          </div>
        </div>
      </Card>

<Card className="p-4 bg-primary/5 border-primary/20">
        <p className="text-sm text-center text-muted-foreground">
          <strong>Note:</strong> Rewards are for promotional purposes. Terms and conditions apply.
        </p>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/risk-disclaimer.tsx" isMerged="true"
"use client"

import { AlertTriangle } from "lucide-react"
import { Card } from "@/components/ui/card"

interface RiskDisclaimerProps {
  context?: "swap" | "send" | "addmoney" | "general"
}

export function RiskDisclaimer({ context = "general" }: RiskDisclaimerProps) {
  const messages = {
    swap: "Token swaps involve smart contract risks, price impact, and slippage. Always verify transaction details before confirming.",
    send: "Cryptocurrency transactions are irreversible. Always double-check the recipient address before sending.",
    addmoney:
      "Cryptocurrency purchases involve third-party payment processors. Ensure you understand all fees and terms before proceeding.",
    general:
      "Cryptocurrency investments are highly volatile and risky. Only invest what you can afford to lose. Not financial advice.",
  }

return (
    <Card className="bg-destructive/5 border-destructive/20 p-3">
      <div className="flex items-start gap-2">
        <AlertTriangle className="w-4 h-4 text-destructive flex-shrink-0 mt-0.5" />
        <div className="space-y-1">
          <p className="text-xs font-medium">Risk Warning</p>
          <p className="text-xs text-muted-foreground">{messages[context]}</p>
        </div>
      </div>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="lib/achievements.ts" isMerged="true"
export interface Achievement {
  id: string
  title: string
  description: string
  icon: string
  category: "wallet" | "social" | "trading" | "milestone"
  requirement: number
  progress: number
  unlocked: boolean
  unlockedAt?: number
  reward?: string
}

export const ACHIEVEMENTS: Omit<Achievement, "progress" | "unlocked">[] = [
  {
    id: "first_connection",
    title: "Welcome Aboard",
    description: "Connect your first wallet",
    icon: "🎉",
    category: "wallet",
    requirement: 1,
    reward: "+5 XP",
  },
  {
    id: "first_transaction",
    title: "First Steps",
    description: "Complete your first transaction",
    icon: "🚀",
    category: "trading",
    requirement: 1,
    reward: "+10 XP",
  },
  {
    id: "first_swap",
    title: "Token Trader",
    description: "Complete your first token swap",
    icon: "🔄",
    category: "trading",
    requirement: 1,
    reward: "+15 XP",
  },
  {
    id: "multi_wallet",
    title: "Portfolio Master",
    description: "Connect 3 different wallets",
    icon: "💼",
    category: "wallet",
    requirement: 3,
    reward: "+20 XP",
  },
  {
    id: "social_butterfly",
    title: "Social Butterfly",
    description: "Share LinkFiCrypto 5 times",
    icon: "🦋",
    category: "social",
    requirement: 5,
    reward: "+25 XP",
  },
  {
    id: "referral_starter",
    title: "Referral Starter",
    description: "Refer your first friend",
    icon: "🤝",
    category: "social",
    requirement: 1,
    reward: "+30 XP",
  },
  {
    id: "referral_pro",
    title: "Referral Pro",
    description: "Refer 5 friends",
    icon: "⭐",
    category: "social",
    requirement: 5,
    reward: "+50 XP",
  },
  {
    id: "swap_master",
    title: "Swap Master",
    description: "Complete 10 token swaps",
    icon: "💎",
    category: "trading",
    requirement: 10,
    reward: "+100 XP",
  },
  {
    id: "week_streak",
    title: "Week Warrior",
    description: "Use LinkFiCrypto for 7 consecutive days",
    icon: "🔥",
    category: "milestone",
    requirement: 7,
    reward: "+75 XP",
  },
  {
    id: "power_user",
    title: "Power User",
    description: "Complete 50 total transactions",
    icon: "⚡",
    category: "milestone",
    requirement: 50,
    reward: "+200 XP",
  },
]

export function getAchievements(address: string): Achievement[] {
  if (typeof window === "undefined") {
    return ACHIEVEMENTS.map((a) => ({ ...a, progress: 0, unlocked: false }))
  }

try {
    const saved = localStorage.getItem(`achievements_${address}`)
    if (saved) {
      return JSON.parse(saved)
    }

return ACHIEVEMENTS.map((a) => ({ ...a, progress: 0, unlocked: false }))
  } catch (error) {
    console.error("Error loading achievements:", error)
    return ACHIEVEMENTS.map((a) => ({ ...a, progress: 0, unlocked: false }))
  }
}

export function saveAchievements(address: string, achievements: Achievement[]): void {
  if (typeof window === "undefined") return

try {
    localStorage.setItem(`achievements_${address}`, JSON.stringify(achievements))
  } catch (error) {
    console.error("Error saving achievements:", error)
  }
}

export function updateAchievementProgress(
  address: string,
  achievementId: string,
  progress: number,
): Achievement | null {
  const achievements = getAchievements(address)
  const achievement = achievements.find((a) => a.id === achievementId)

if (!achievement || achievement.unlocked) return null

achievement.progress = Math.min(progress, achievement.requirement)

if (achievement.progress >= achievement.requirement && !achievement.unlocked) {
    achievement.unlocked = true
    achievement.unlockedAt = Date.now()
    saveAchievements(address, achievements)
    return achievement
  }

saveAchievements(address, achievements)
  return null
}

export function getStats(address: string): {
  totalXP: number
  unlockedCount: number
  totalCount: number
  level: number
} {
  const achievements = getAchievements(address)
  const unlocked = achievements.filter((a) => a.unlocked)

const totalXP = unlocked.reduce((sum, a) => {
    const xp = Number.parseInt(a.reward?.replace(/[^\d]/g, "") || "0")
    return sum + xp
  }, 0)

const level = Math.floor(totalXP / 100) + 1

return {
    totalXP,
    unlockedCount: unlocked.length,
    totalCount: achievements.length,
    level,
  }
}

export function trackWalletConnection(address: string): Achievement | null {
  return updateAchievementProgress(address, "first_connection", 1)
}

export function trackTransaction(address: string): Achievement | null {
  const achievements = getAchievements(address)
  const firstTx = achievements.find((a) => a.id === "first_transaction")
  if (firstTx && !firstTx.unlocked) {
    return updateAchievementProgress(address, "first_transaction", 1)
  }
  return null
}

export function trackSwap(address: string, count: number): Achievement | null {
  const achievements = getAchievements(address)
  const firstSwap = achievements.find((a) => a.id === "first_swap")
  const swapMaster = achievements.find((a) => a.id === "swap_master")

let newAchievement: Achievement | null = null

if (firstSwap && !firstSwap.unlocked) {
    newAchievement = updateAchievementProgress(address, "first_swap", 1)
  }

if (swapMaster && !swapMaster.unlocked) {
    const unlocked = updateAchievementProgress(address, "swap_master", count)
    if (unlocked) newAchievement = unlocked
  }

return newAchievement
}

export function trackShare(address: string, count: number): Achievement | null {
  return updateAchievementProgress(address, "social_butterfly", count)
}

export function trackReferral(address: string, count: number): Achievement | null {
  const achievements = getAchievements(address)
  const starter = achievements.find((a) => a.id === "referral_starter")
  const pro = achievements.find((a) => a.id === "referral_pro")

let newAchievement: Achievement | null = null

if (starter && !starter.unlocked) {
    newAchievement = updateAchievementProgress(address, "referral_starter", count)
  }

if (pro && !pro.unlocked) {
    const unlocked = updateAchievementProgress(address, "referral_pro", count)
    if (unlocked) newAchievement = unlocked
  }

return newAchievement
}
[V0_FILE]typescriptreact:file="components/achievements-interface.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Trophy, Lock, CheckCircle2, Star } from "lucide-react"
import { getAchievements, getStats, type Achievement } from "@/lib/achievements"
import { Progress } from "@/components/ui/progress"

interface AchievementsInterfaceProps {
  address: string
}

export function AchievementsInterface({ address }: AchievementsInterfaceProps) {
  const [achievements, setAchievements] = useState<Achievement[]>([])
  const [filter, setFilter] = useState<"all" | "wallet" | "social" | "trading" | "milestone">("all")
  const [stats, setStats] = useState({ totalXP: 0, unlockedCount: 0, totalCount: 0, level: 1 })

useEffect(() => {
    if (!address) return

const loadedAchievements = getAchievements(address)
    setAchievements(loadedAchievements)

const loadedStats = getStats(address)
    setStats(loadedStats)
  }, [address])

const filteredAchievements = achievements.filter((a) => filter === "all" || a.category === filter)

return (
    <div className="space-y-6">
      <Card className="p-6 bg-gradient-to-br from-primary/10 to-amber-500/10 border-primary/20">
        <div className="flex items-center gap-4 mb-4">
          <div className="w-16 h-16 rounded-full bg-gradient-to-br from-primary to-amber-500 flex items-center justify-center">
            <Trophy className="w-8 h-8 text-white" />
          </div>
          <div className="flex-1">
            <h2 className="text-2xl font-bold">Achievements</h2>
            <p className="text-sm text-muted-foreground">
              Level {stats.level} • {stats.totalXP} XP
            </p>
          </div>
        </div>

<div className="grid grid-cols-3 gap-4">
          <div className="text-center p-3 rounded-lg bg-background/50">
            <div className="text-2xl font-bold">{stats.unlockedCount}</div>
            <div className="text-xs text-muted-foreground">Unlocked</div>
          </div>
          <div className="text-center p-3 rounded-lg bg-background/50">
            <div className="text-2xl font-bold">{stats.level}</div>
            <div className="text-xs text-muted-foreground">Level</div>
          </div>
          <div className="text-center p-3 rounded-lg bg-background/50">
            <div className="text-2xl font-bold">{stats.totalXP}</div>
            <div className="text-xs text-muted-foreground">Total XP</div>
          </div>
        </div>

<div className="mt-4">
          <div className="flex items-center justify-between text-sm mb-2">
            <span className="text-muted-foreground">Next Level</span>
            <span className="font-medium">{stats.totalXP % 100} / 100 XP</span>
          </div>
          <Progress value={stats.totalXP % 100} className="h-2" />
        </div>
      </Card>

<div className="flex gap-2 overflow-x-auto pb-2">
        <button
          onClick={() => setFilter("all")}
          className={`px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap transition-colors ${
            filter === "all" ? "bg-primary text-primary-foreground" : "bg-muted text-muted-foreground hover:bg-muted/80"
          }`}
        >
          All
        </button>
        <button
          onClick={() => setFilter("wallet")}
          className={`px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap transition-colors ${
            filter === "wallet"
              ? "bg-primary text-primary-foreground"
              : "bg-muted text-muted-foreground hover:bg-muted/80"
          }`}
        >
          Wallet
        </button>
        <button
          onClick={() => setFilter("trading")}
          className={`px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap transition-colors ${
            filter === "trading"
              ? "bg-primary text-primary-foreground"
              : "bg-muted text-muted-foreground hover:bg-muted/80"
          }`}
        >
          Trading
        </button>
        <button
          onClick={() => setFilter("social")}
          className={`px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap transition-colors ${
            filter === "social"
              ? "bg-primary text-primary-foreground"
              : "bg-muted text-muted-foreground hover:bg-muted/80"
          }`}
        >
          Social
        </button>
        <button
          onClick={() => setFilter("milestone")}
          className={`px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap transition-colors ${
            filter === "milestone"
              ? "bg-primary text-primary-foreground"
              : "bg-muted text-muted-foreground hover:bg-muted/80"
          }`}
        >
          Milestone
        </button>
      </div>

<div className="grid gap-4 md:grid-cols-2">
        {filteredAchievements.map((achievement) => (
          <Card
            key={achievement.id}
            className={`p-4 ${
              achievement.unlocked ? "border-primary/50 bg-primary/5" : "border-border bg-card"
            } relative overflow-hidden`}
          >
            {achievement.unlocked && (
              <div className="absolute top-2 right-2">
                <CheckCircle2 className="w-5 h-5 text-success" />
              </div>
            )}

<div className="flex items-start gap-4">
              <div
                className={`w-14 h-14 rounded-full flex items-center justify-center text-2xl ${
                  achievement.unlocked ? "bg-primary/20" : "bg-muted grayscale opacity-50"
                }`}
              >
                {achievement.unlocked ? achievement.icon : <Lock className="w-6 h-6" />}
              </div>

<div className="flex-1">
                <h3 className="font-semibold text-foreground mb-1">{achievement.title}</h3>
                <p className="text-sm text-muted-foreground mb-3">{achievement.description}</p>

{!achievement.unlocked && (
                  <div className="space-y-2">
                    <div className="flex items-center justify-between text-xs text-muted-foreground">
                      <span>Progress</span>
                      <span>
                        {achievement.progress} / {achievement.requirement}
                      </span>
                    </div>
                    <Progress value={(achievement.progress / achievement.requirement) * 100} className="h-2" />
                  </div>
                )}

{achievement.reward && (
                  <div className="mt-3 flex items-center gap-2">
                    <Star className="w-4 h-4 text-amber-500" />
                    <span className="text-xs font-medium text-amber-600 dark:text-amber-500">{achievement.reward}</span>
                  </div>
                )}

{achievement.unlocked && achievement.unlockedAt && (
                  <div className="mt-2 text-xs text-muted-foreground">
                    Unlocked {new Date(achievement.unlockedAt).toLocaleDateString()}
                  </div>
                )}
              </div>
            </div>
          </Card>
        ))}
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/achievement-toast.tsx" isMerged="true"
"use client"

import { useEffect, useState } from "react"
import { Trophy, X } from "lucide-react"
import { Card } from "@/components/ui/card"
import type { Achievement } from "@/lib/achievements"

interface AchievementToastProps {
  achievement: Achievement | null
  onClose: () => void
}

export function AchievementToast({ achievement, onClose }: AchievementToastProps) {
  const [isVisible, setIsVisible] = useState(false)

useEffect(() => {
    if (achievement) {
      setIsVisible(true)

const timer = setTimeout(() => {
        setIsVisible(false)
        setTimeout(onClose, 300)
      }, 5000)

return () => clearTimeout(timer)
    }
  }, [achievement, onClose])

if (!achievement) return null

return (
    <div
      className={`fixed top-4 right-4 z-50 transition-all duration-300 ${
        isVisible ? "translate-x-0 opacity-100" : "translate-x-full opacity-0"
      }`}
    >
      <Card className="p-4 bg-gradient-to-br from-primary to-amber-500 text-white border-none shadow-lg max-w-sm">
        <div className="flex items-start gap-3">
          <div className="w-12 h-12 rounded-full bg-white/20 flex items-center justify-center text-2xl flex-shrink-0">
            {achievement.icon}
          </div>

<div className="flex-1 min-w-0">
            <div className="flex items-center gap-2 mb-1">
              <Trophy className="w-4 h-4" />
              <h3 className="font-semibold">Achievement Unlocked!</h3>
            </div>
            <p className="text-sm font-medium mb-1">{achievement.title}</p>
            <p className="text-xs text-white/90">{achievement.description}</p>
            {achievement.reward && <p className="text-xs font-medium mt-2 text-amber-200">{achievement.reward}</p>}
          </div>

<button
            onClick={() => {
              setIsVisible(false)
              setTimeout(onClose, 300)
            }}
            className="text-white/80 hover:text-white transition-colors"
          >
            <X className="w-4 h-4" />
          </button>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/footer-disclaimer.tsx" isMerged="true"
"use client"

import { Info } from "lucide-react"
import Link from "next/link"

export function FooterDisclaimer() {
  return (
    <footer className="border-t border-border mt-8">
      <div className="container mx-auto px-4 py-4">
        <div className="flex flex-col sm:flex-row items-center justify-center gap-3 text-center">
          <div className="flex items-center gap-2 text-xs text-muted-foreground">
            <Info className="w-3.5 h-3.5 flex-shrink-0" />
            <span>Not financial advice. Crypto assets are volatile and risky.</span>
          </div>
          <div className="flex items-center gap-3 text-xs">
            <Link href="/terms" className="text-muted-foreground hover:text-foreground transition-colors">
              Terms
            </Link>
            <span className="text-muted-foreground">•</span>
            <Link href="/privacy" className="text-muted-foreground hover:text-foreground transition-colors">
              Privacy
            </Link>
          </div>
        </div>
      </div>
    </footer>
  )
}
[V0_FILE]typescriptreact:file="components/social-share.tsx" isEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import { Button } from "@/components/ui/button"
import { Share2, Twitter, MessageCircle, Copy, Check } from "lucide-react"
import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu"

interface SocialShareProps {
  title?: string
  text?: string
  url?: string
}

export function SocialShare({ title, text, url }: SocialShareProps) {
  const [copied, setCopied] = useState(false)

const currentUrl = typeof window !== "undefined" ? window.location.href : "https://linkficrypto.com"

const shareData = {
    title: title || "LinkFiCrypto - Secure Non-Custodial Crypto Wallet",
    text:
      text || "Check out LinkFiCrypto - a secure non-custodial wallet with the best DEX rates and multi-chain support!",
    url: url || currentUrl,
  }

const handleNativeShare = async () => {
    if (navigator.share) {
      try {
        await navigator.share(shareData)
      } catch (error) {
        console.log("Share cancelled")
      }
    }
  }

const handleCopyLink = async () => {
    try {
      await navigator.clipboard.writeText(shareData.url)
      setCopied(true)
      setTimeout(() => setCopied(false), 2000)
    } catch (error) {
      console.error("Failed to copy link")
    }
  }

const shareUrls = {
    twitter: `https://twitter.com/intent/tweet?text=${encodeURIComponent(shareData.text)}&url=${encodeURIComponent(shareData.url)}`,
    telegram: `https://t.me/share/url?url=${encodeURIComponent(shareData.url)}&text=${encodeURIComponent(shareData.text)}`,
    whatsapp: `https://api.whatsapp.com/send?text=${encodeURIComponent(`${shareData.text} ${shareData.url}`)}`,
  }

const hasNativeShare = typeof window !== "undefined" && navigator.share

return (
    <DropdownMenu>
      <DropdownMenuTrigger asChild>
        <Button variant="outline" size="sm">
          <Share2 className="w-4 h-4 mr-2" />
          Share
        </Button>
      </DropdownMenuTrigger>
      <DropdownMenuContent align="end" className="w-48">
        {hasNativeShare && (
          <DropdownMenuItem onClick={handleNativeShare}>
            <Share2 className="w-4 h-4 mr-2" />
            Share via...
          </DropdownMenuItem>
        )}
        <DropdownMenuItem onClick={() => window.open(shareUrls.twitter, "_blank", "width=550,height=420")}>
          <Twitter className="w-4 h-4 mr-2" />
          Share on X
        </DropdownMenuItem>
        <DropdownMenuItem onClick={() => window.open(shareUrls.telegram, "_blank", "width=550,height=420")}>
          <MessageCircle className="w-4 h-4 mr-2" />
          Share on Telegram
        </DropdownMenuItem>
        <DropdownMenuItem onClick={() => window.open(shareUrls.whatsapp, "_blank", "width=550,height=420")}>
          <MessageCircle className="w-4 h-4 mr-2" />
          Share on WhatsApp
        </DropdownMenuItem>
        <DropdownMenuItem onClick={handleCopyLink}>
          {copied ? <Check className="w-4 h-4 mr-2" /> : <Copy className="w-4 h-4 mr-2" />}
          {copied ? "Copied!" : "Copy Link"}
        </DropdownMenuItem>
      </DropdownMenuContent>
    </DropdownMenu>
  )
}
[V0_FILE]jpg:file="public/og-image.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/FD8B3252-E7A2-4E95-AE5D-228B8A098F5A-p7CjxVwO8THMz0D3M6OIomuRVkXnpY.jpeg" isMerged="true"
[V0_FILE]typescriptreact:file="components/portfolio-analytics.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { TrendingUp, TrendingDown, PieChart, BarChart3, Activity, AlertCircle } from "lucide-react"
import { Button } from "@/components/ui/button"

interface Token {
  symbol: string
  balance: string
  priceUSD: number
  change24h: number
  valueUSD: number
  name: string
}

interface PortfolioAnalyticsProps {
  walletAddress: string
  provider: any
}

export function PortfolioAnalytics({ walletAddress, provider }: PortfolioAnalyticsProps) {
  const [tokens, setTokens] = useState<Token[]>([])
  const [totalValue, setTotalValue] = useState(0)
  const [change24h, setChange24h] = useState(0)
  const [loading, setLoading] = useState(true)
  const [timeRange, setTimeRange] = useState<"24h" | "7d" | "30d" | "all">("24h")

useEffect(() => {
    const fetchRealTokenData = async () => {
      setLoading(true)
      try {
        // Get ETH balance
        const ethBalanceHex = await provider.request({
          method: "eth_getBalance",
          params: [walletAddress, "latest"],
        })
        const ethBalance = Number.parseInt(ethBalanceHex, 16) / 1e18

// Popular tokens to check
        const popularTokens = [
          {
            address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
            symbol: "USDT",
            name: "Tether USD",
            decimals: 6,
          },
          {
            address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
            symbol: "USDC",
            name: "USD Coin",
            decimals: 6,
          },
          {
            address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
            symbol: "DAI",
            name: "Dai Stablecoin",
            decimals: 18,
          },
          {
            address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
            symbol: "WBTC",
            name: "Wrapped BTC",
            decimals: 8,
          },
          {
            address: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
            symbol: "UNI",
            name: "Uniswap",
            decimals: 18,
          },
          {
            address: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
            symbol: "LINK",
            name: "Chainlink",
            decimals: 18,
          },
        ]

// Fetch price data from CoinGecko for real prices
        const priceResponse = await fetch(
          "https://api.coingecko.com/api/v3/simple/price?ids=ethereum,tether,usd-coin,dai,wrapped-bitcoin,uniswap,chainlink&vs_currencies=usd&include_24hr_change=true",
        )
        const priceData = await priceResponse.json()

const priceMap: Record<string, { price: number; change: number }> = {
          ETH: { price: priceData.ethereum?.usd || 0, change: priceData.ethereum?.usd_24h_change || 0 },
          USDT: { price: priceData.tether?.usd || 0, change: priceData.tether?.usd_24h_change || 0 },
          USDC: { price: priceData["usd-coin"]?.usd || 0, change: priceData["usd-coin"]?.usd_24h_change || 0 },
          DAI: { price: priceData.dai?.usd || 0, change: priceData.dai?.usd_24h_change || 0 },
          WBTC: {
            price: priceData["wrapped-bitcoin"]?.usd || 0,
            change: priceData["wrapped-bitcoin"]?.usd_24h_change || 0,
          },
          UNI: { price: priceData.uniswap?.usd || 0, change: priceData.uniswap?.usd_24h_change || 0 },
          LINK: { price: priceData.chainlink?.usd || 0, change: priceData.chainlink?.usd_24h_change || 0 },
        }

const tokenList: Token[] = []

// Add ETH if balance > 0
        if (ethBalance > 0) {
          tokenList.push({
            symbol: "ETH",
            name: "Ethereum",
            balance: ethBalance.toFixed(4),
            priceUSD: priceMap.ETH.price,
            change24h: priceMap.ETH.change,
            valueUSD: ethBalance * priceMap.ETH.price,
          })
        }

// Fetch ERC-20 token balances
        const tokenBalances = await Promise.all(
          popularTokens.map(async (token) => {
            try {
              const balance = await provider.request({
                method: "eth_call",
                params: [
                  {
                    to: token.address,
                    data: `0x70a08231000000000000000000000000${walletAddress.slice(2)}`,
                  },
                  "latest",
                ],
              })

const balanceNum = Number.parseInt(balance, 16) / Math.pow(10, token.decimals)
              if (balanceNum > 0) {
                const priceInfo = priceMap[token.symbol] || { price: 0, change: 0 }
                return {
                  symbol: token.symbol,
                  name: token.name,
                  balance: balanceNum.toFixed(4),
                  priceUSD: priceInfo.price,
                  change24h: priceInfo.change,
                  valueUSD: balanceNum * priceInfo.price,
                }
              }
              return null
            } catch (error) {
              return null
            }
          }),
        )

// Filter out null values and add to token list
        tokenBalances.forEach((token) => {
          if (token) tokenList.push(token)
        })

setTokens(tokenList)

// Calculate total portfolio value
        const total = tokenList.reduce((sum, token) => sum + token.valueUSD, 0)
        setTotalValue(total)

// Calculate weighted average 24h change
        const weightedChange =
          total > 0
            ? tokenList.reduce((sum, token) => {
                const weight = token.valueUSD / total
                return sum + token.change24h * weight
              }, 0)
            : 0
        setChange24h(weightedChange)
      } catch (error) {
        console.error("Error fetching portfolio data:", error)
      } finally {
        setLoading(false)
      }
    }

fetchRealTokenData()
  }, [walletAddress, provider])

const formatCurrency = (value: number) => {
    return new Intl.NumberFormat("en-US", {
      style: "currency",
      currency: "USD",
      minimumFractionDigits: 2,
    }).format(value)
  }

const formatPercent = (value: number) => {
    const sign = value >= 0 ? "+" : ""
    return `${sign}${value.toFixed(2)}%`
  }

const topPerformer = tokens.reduce(
    (max, token) => (token.change24h > max.change24h ? token : max),
    tokens[0] || { symbol: "", change24h: 0, name: "" },
  )

const bottomPerformer = tokens.reduce(
    (min, token) => (token.change24h < min.change24h ? token : min),
    tokens[0] || { symbol: "", change24h: 0, name: "" },
  )

if (loading) {
    return (
      <div className="flex items-center justify-center min-h-[400px]">
        <div className="text-center">
          <div className="w-12 h-12 border-4 border-primary border-t-transparent rounded-full animate-spin mx-auto mb-4"></div>
          <p className="text-muted-foreground">Loading portfolio analytics...</p>
        </div>
      </div>
    )
  }

if (tokens.length === 0) {
    return (
      <Card className="p-12">
        <div className="text-center space-y-3">
          <BarChart3 className="w-16 h-16 mx-auto text-muted-foreground/50" />
          <h3 className="text-xl font-semibold">No Assets Found</h3>
          <p className="text-muted-foreground max-w-md mx-auto">
            Your wallet doesn't have any assets yet. Add funds to your wallet to see portfolio analytics.
          </p>
        </div>
      </Card>
    )
  }

return (
    <div className="space-y-6">
      {/* Header Stats */}
      <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
        <Card className="p-6 bg-gradient-to-br from-primary/10 to-primary/5 border-primary/20">
          <div className="space-y-2">
            <p className="text-sm text-muted-foreground font-medium">Total Portfolio Value</p>
            <p className="text-3xl font-bold">{formatCurrency(totalValue)}</p>
            <div className="flex items-center gap-2">
              {change24h >= 0 ? (
                <TrendingUp className="w-4 h-4 text-green-500" />
              ) : (
                <TrendingDown className="w-4 h-4 text-red-500" />
              )}
              <span className={change24h >= 0 ? "text-green-500 font-semibold" : "text-red-500 font-semibold"}>
                {formatPercent(change24h)}
              </span>
              <span className="text-xs text-muted-foreground">24h</span>
            </div>
          </div>
        </Card>

<Card className="p-6 bg-card border-border">
          <div className="space-y-2">
            <div className="flex items-center gap-2">
              <TrendingUp className="w-4 h-4 text-green-500" />
              <p className="text-sm text-muted-foreground font-medium">Top Performer</p>
            </div>
            <p className="text-2xl font-bold">{topPerformer.symbol}</p>
            <p className="text-green-500 font-semibold">{formatPercent(topPerformer.change24h)}</p>
          </div>
        </Card>

<Card className="p-6 bg-card border-border">
          <div className="space-y-2">
            <div className="flex items-center gap-2">
              <TrendingDown className="w-4 h-4 text-red-500" />
              <p className="text-sm text-muted-foreground font-medium">Bottom Performer</p>
            </div>
            <p className="text-2xl font-bold">{bottomPerformer.symbol}</p>
            <p className="text-red-500 font-semibold">{formatPercent(bottomPerformer.change24h)}</p>
          </div>
        </Card>
      </div>

{/* Time Range Selector */}
      <div className="flex gap-2">
        {(["24h", "7d", "30d", "all"] as const).map((range) => (
          <Button
            key={range}
            variant={timeRange === range ? "default" : "outline"}
            size="sm"
            onClick={() => setTimeRange(range)}
          >
            {range === "all" ? "All Time" : range.toUpperCase()}
          </Button>
        ))}
      </div>

{/* Charts Grid */}
      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
        {/* Asset Allocation */}
        <Card className="p-6">
          <div className="flex items-center gap-2 mb-4">
            <PieChart className="w-5 h-5 text-primary" />
            <h3 className="text-lg font-semibold">Asset Allocation</h3>
          </div>
          <div className="space-y-3">
            {tokens.map((token, index) => {
              const percentage = (token.valueUSD / totalValue) * 100
              const colors = ["bg-blue-500", "bg-green-500", "bg-purple-500", "bg-orange-500", "bg-pink-500"]
              return (
                <div key={token.symbol} className="space-y-1">
                  <div className="flex justify-between text-sm">
                    <span className="font-medium">{token.symbol}</span>
                    <span className="text-muted-foreground">{percentage.toFixed(1)}%</span>
                  </div>
                  <div className="w-full h-2 bg-muted rounded-full overflow-hidden">
                    <div
                      className={`h-full ${colors[index % colors.length]} transition-all`}
                      style={{ width: `${percentage}%` }}
                    />
                  </div>
                </div>
              )
            })}
          </div>
        </Card>

{/* Performance Chart Placeholder */}
        <Card className="p-6">
          <div className="flex items-center gap-2 mb-4">
            <Activity className="w-5 h-5 text-primary" />
            <h3 className="text-lg font-semibold">Portfolio Performance</h3>
          </div>
          <div className="h-[200px] flex items-end justify-between gap-2">
            {[65, 78, 85, 72, 90, 88, 95, 92, 98, 100, 105, 110].map((height, index) => (
              <div
                key={index}
                className="flex-1 bg-gradient-to-t from-primary to-primary/50 rounded-t transition-all hover:opacity-80"
                style={{ height: `${height}%` }}
              />
            ))}
          </div>
          <div className="flex justify-between mt-2 text-xs text-muted-foreground">
            <span>Start</span>
            <span>Now</span>
          </div>
        </Card>
      </div>

{/* Token Breakdown */}
      <Card className="p-6">
        <div className="flex items-center gap-2 mb-4">
          <BarChart3 className="w-5 h-5 text-primary" />
          <h3 className="text-lg font-semibold">Holdings Breakdown</h3>
        </div>
        <div className="overflow-x-auto">
          <table className="w-full">
            <thead>
              <tr className="border-b border-border text-left">
                <th className="pb-3 font-semibold text-sm">Asset</th>
                <th className="pb-3 font-semibold text-sm text-right">Balance</th>
                <th className="pb-3 font-semibold text-sm text-right">Price</th>
                <th className="pb-3 font-semibold text-sm text-right">24h Change</th>
                <th className="pb-3 font-semibold text-sm text-right">Value</th>
                <th className="pb-3 font-semibold text-sm text-right">Allocation</th>
              </tr>
            </thead>
            <tbody>
              {tokens.map((token) => {
                const percentage = (token.valueUSD / totalValue) * 100
                return (
                  <tr key={token.symbol} className="border-b border-border/50 last:border-0">
                    <td className="py-4 font-semibold">{token.symbol}</td>
                    <td className="py-4 text-right text-muted-foreground">{token.balance}</td>
                    <td className="py-4 text-right">{formatCurrency(token.priceUSD)}</td>
                    <td className="py-4 text-right">
                      <span className={token.change24h >= 0 ? "text-green-500" : "text-red-500"}>
                        {formatPercent(token.change24h)}
                      </span>
                    </td>
                    <td className="py-4 text-right font-semibold">{formatCurrency(token.valueUSD)}</td>
                    <td className="py-4 text-right text-muted-foreground">{percentage.toFixed(1)}%</td>
                  </tr>
                )
              })}
            </tbody>
          </table>
        </div>
      </Card>

{/* Insights */}
      <Card className="p-6 bg-blue-500/5 border-blue-500/20">
        <div className="flex items-start gap-3">
          <AlertCircle className="w-5 h-5 text-blue-500 mt-0.5 flex-shrink-0" />
          <div className="space-y-2">
            <h4 className="font-semibold text-blue-500">Portfolio Insights</h4>
            <ul className="space-y-1 text-sm text-muted-foreground">
              <li>
                Your portfolio is {change24h >= 0 ? "up" : "down"} {formatPercent(Math.abs(change24h))} in the last 24
                hours
              </li>
              <li>
                {topPerformer.symbol} is your best performer with {formatPercent(topPerformer.change24h)} gains
              </li>
              <li>
                {tokens.length} assets tracked with {formatCurrency(totalValue)} total value
              </li>
            </ul>
          </div>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="lib/supabase/server.ts" isMerged="true"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"

export async function createClient() {
  const cookieStore = await cookies()

return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, {
    cookies: {
      getAll() {
        return cookieStore.getAll()
      },
      setAll(cookiesToSet) {
        try {
          cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
        } catch {
          // Ignore - setAll called from Server Component with middleware
        }
      },
    },
  })
}
[V0_FILE]typescriptreact:file="next.config.mjs" isFixed="true" isQuickEdit="true" isMerged="true"
/** @type {import('next').NextConfig} */
const nextConfig = {
  eslint: {
    ignoreDuringBuilds: true,
  },
  typescript: {
    ignoreBuildErrors: true,
  },
  images: {
    unoptimized: true,
  },
  env: {
    NEXT_PUBLIC_SUPABASE_URL: process.env.NEXT_PUBLIC_SUPABASE_URL,
    NEXT_PUBLIC_SUPABASE_ANON_KEY: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
  },
}

export default nextConfig
[V0_FILE]typescriptreact:file="app/auth/callback/route.ts" isEdit="true" isMerged="true"
import { createServerClient } from "@supabase/ssr"
import { NextResponse } from "next/server"
import { cookies } from "next/headers"

export async function GET(request: Request) {
  const { searchParams, origin } = new URL(request.url)
  const code = searchParams.get("code")
  const next = searchParams.get("next") ?? "/"

if (code) {
    const cookieStore = await cookies()
    const supabase = createServerClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
      {
        cookies: {
          getAll() {
            return cookieStore.getAll()
          },
          setAll(cookiesToSet) {
            try {
              cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
            } catch {}
          },
        },
      },
    )

const { error } = await supabase.auth.exchangeCodeForSession(code)

if (!error) {
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (user) {
        const { data: existingProfile } = await supabase.from("profiles").select("id").eq("id", user.id).single()

if (!existingProfile) {
          // Create profile with wallet data from user metadata
          await supabase.from("profiles").insert({
            id: user.id,
            username: user.user_metadata?.username || null,
            wallet_address: user.user_metadata?.wallet_address || null,
            builtin_wallet_address: user.user_metadata?.wallet_address || null,
            has_builtin_wallet: user.user_metadata?.has_wallet || false,
          })
        }
      }

return NextResponse.redirect(`${origin}`)
    }
  }

return NextResponse.redirect(`${origin}/auth/login?error=confirmation_failed`)
}
[V0_FILE]typescriptreact:file="app/payments/page.tsx" isFixed="true" isQuickEdit="true" isMerged="true"
// Ensure there is a default export
export default function PaymentsPage() {
  // Existing code here
}
[V0_FILE]typescript:file="lib/supabase/client.ts" isMerged="true"
import { createBrowserClient } from "@supabase/ssr"
import type { SupabaseClient } from "@supabase/supabase-js"

// Reuse a single browser client across the app to avoid
// "Multiple GoTrueClient instances detected" and flaky session persistence.
let client: SupabaseClient | undefined

export function createClient() {
  if (client) return client

client = createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
  )

return client
}

export { createBrowserClient }
[V0_FILE]typescriptreact:file="components/payment-dashboard.tsx" isMerged="true"
"use client"

interface PaymentDashboardProps {
  walletAddress: string
}

export function PaymentDashboard({ walletAddress }: PaymentDashboardProps) {
  const [user, setUser] = useState<any>(null)
  const [profile, setProfile] = useState<any>(null)
  const [loading, setLoading] = useState(true)
  const supabase = createClient()

useEffect(() => {
    checkUser()
  }, [])

const checkUser = async () => {
    const {
      data: { user },
    } = await supabase.auth.getUser()

if (user) {
      setUser(user)
      const { data: profileData } = await supabase.from("user_profiles").select("*").eq("user_id", user.id).single()

setProfile(profileData)
    }
    setLoading(false)
  }

const handleSignOut = async () => {
    await supabase.auth.signOut()
    setUser(null)
    setProfile(null)
  }

if (loading) {
    return (
      <Card>
        <CardContent className="py-8">
          <div className="text-center">
            <div className="w-8 h-8 border-4 border-primary border-t-transparent rounded-full animate-spin mx-auto mb-4"></div>
            <p className="text-muted-foreground">Loading payment features...</p>
          </div>
        </CardContent>
      </Card>
    )
  }

if (!user) {
    return (
      <Card>
        <CardHeader>
          <CardTitle>Payment Features</CardTitle>
          <CardDescription>Sign in to access PayPal-style crypto payments</CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <p className="text-muted-foreground">
            Create an account to send payments using @usernames, request payments, and generate merchant payment links.
          </p>
          <div className="flex gap-3">
            <Button onClick={() => (window.location.href = "/auth/login")} variant="outline" className="flex-1">
              Sign In
            </Button>
            <Button onClick={() => (window.location.href = "/auth/sign-up")} className="flex-1">
              Create Account
            </Button>
          </div>
        </CardContent>
      </Card>
    )
  }

return (
    <div className="space-y-4">
      <Card>
        <CardHeader>
          <div className="flex items-center justify-between">
            <div className="flex items-center gap-3">
              <User className="h-5 w-5" />
              <div>
                <CardTitle className="text-lg">
                  {profile?.username ? `@${profile.username}` : "Complete Your Profile"}
                </CardTitle>
                <CardDescription>{user.email}</CardDescription>
              </div>
            </div>
            <Button onClick={handleSignOut} variant="ghost" size="sm">
              <LogOut className="h-4 w-4 mr-2" />
              Sign Out
            </Button>
          </div>
        </CardHeader>
      </Card>

{!profile?.username && (
        <Card className="bg-yellow-500/10 border-yellow-500/50">
          <CardContent className="py-4">
            <p className="text-sm">
              <strong>Action Required:</strong> Set up your @username to start sending and receiving payments.{" "}
              <Button
                variant="link"
                className="p-0 h-auto"
                onClick={() => (window.location.href = "/auth/profile-setup")}
              >
                Complete Profile
              </Button>
            </p>
          </CardContent>
        </Card>
      )}

<Tabs defaultValue="send" className="w-full">
        <TabsList className="grid w-full grid-cols-3">
          <TabsTrigger value="send">Send Payment</TabsTrigger>
          <TabsTrigger value="request">Request Payment</TabsTrigger>
          <TabsTrigger value="merchant">Merchant Tools</TabsTrigger>
        </TabsList>
        <TabsContent value="send">
          <PaymentSend />
        </TabsContent>
        <TabsContent value="request">
          <PaymentRequest />
        </TabsContent>
        <TabsContent value="merchant">
          <PaymentLinkGenerator />
        </TabsContent>
      </Tabs>
    </div>
  )
}
[V0_FILE]sql:file="scripts/001_create_payment_tables.sql" isEdit="true" isMerged="true"
-- Enable UUID extension
create extension if not exists "uuid-ossp";

-- User profiles table with username for @username payments
create table if not exists public.profiles (
  id uuid primary key references auth.users(id) on delete cascade,
  username text unique not null,
  display_name text,
  wallet_address text,
  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
  updated_at timestamp with time zone default timezone('utc'::text, now()) not null,
  constraint username_length check (char_length(username) >= 3 and char_length(username) <= 30),
  constraint username_format check (username ~ '^[a-zA-Z0-9_]+$')
);

-- Payment requests table
create table if not exists public.payment_requests (
  id uuid primary key default uuid_generate_v4(),
  user_id uuid references auth.users(id) on delete cascade not null,
  recipient_username text,
  recipient_wallet text,
  amount numeric(20, 8) not null,
  token text not null,
  note text,
  status text not null default 'pending',
  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
  expires_at timestamp with time zone,
  paid_at timestamp with time zone,
  tx_hash text,
  constraint valid_status check (status in ('pending', 'paid', 'cancelled', 'expired'))
);

-- Payment links table (for merchants)
create table if not exists public.payment_links (
  id uuid primary key default uuid_generate_v4(),
  user_id uuid references auth.users(id) on delete cascade not null,
  title text not null,
  description text,
  amount numeric(20, 8) not null,
  token text not null,
  link_code text unique not null,
  is_active boolean default true,
  max_uses integer,
  current_uses integer default 0,
  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
  expires_at timestamp with time zone
);

-- Contacts table (saved payment recipients)
create table if not exists public.contacts (
  id uuid primary key default uuid_generate_v4(),
  user_id uuid references auth.users(id) on delete cascade not null,
  contact_username text,
  contact_wallet text,
  nickname text,
  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
  constraint contact_identifier check (contact_username is not null or contact_wallet is not null),
  unique(user_id, contact_username),
  unique(user_id, contact_wallet)
);

-- Transaction history table
create table if not exists public.transactions (
  id uuid primary key default uuid_generate_v4(),
  user_id uuid references auth.users(id) on delete cascade not null,
  type text not null,
  amount numeric(20, 8) not null,
  token text not null,
  from_address text,
  to_address text,
  tx_hash text unique,
  note text,
  status text not null default 'pending',
  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
  confirmed_at timestamp with time zone,
  constraint valid_type check (type in ('send', 'receive', 'swap')),
  constraint valid_status check (status in ('pending', 'confirmed', 'failed'))
);

-- Enable Row Level Security
alter table public.profiles enable row level security;
alter table public.payment_requests enable row level security;
alter table public.payment_links enable row level security;
alter table public.contacts enable row level security;
alter table public.transactions enable row level security;

-- Profiles policies
create policy "profiles_select_all" on public.profiles for select using (true);
create policy "profiles_insert_own" on public.profiles for insert with check (auth.uid() = id);
create policy "profiles_update_own" on public.profiles for update using (auth.uid() = id);

-- Payment requests policies
create policy "payment_requests_select_own" on public.payment_requests for select using (auth.uid() = user_id);
create policy "payment_requests_insert_own" on public.payment_requests for insert with check (auth.uid() = user_id);
create policy "payment_requests_update_own" on public.payment_requests for update using (auth.uid() = user_id);
create policy "payment_requests_delete_own" on public.payment_requests for delete using (auth.uid() = user_id);

-- Payment links policies
create policy "payment_links_select_own" on public.payment_links for select using (auth.uid() = user_id);
create policy "payment_links_insert_own" on public.payment_links for insert with check (auth.uid() = user_id);
create policy "payment_links_update_own" on public.payment_links for update using (auth.uid() = user_id);
create policy "payment_links_delete_own" on public.payment_links for delete using (auth.uid() = user_id);

-- Contacts policies
create policy "contacts_select_own" on public.contacts for select using (auth.uid() = user_id);
create policy "contacts_insert_own" on public.contacts for insert with check (auth.uid() = user_id);
create policy "contacts_update_own" on public.contacts for update using (auth.uid() = user_id);
create policy "contacts_delete_own" on public.contacts for delete using (auth.uid() = user_id);

-- Transactions policies
create policy "transactions_select_own" on public.transactions for select using (auth.uid() = user_id);
create policy "transactions_insert_own" on public.transactions for insert with check (auth.uid() = user_id);
create policy "transactions_update_own" on public.transactions for update using (auth.uid() = user_id);

-- Create indexes for performance
create index if not exists profiles_username_idx on public.profiles(username);
create index if not exists payment_requests_user_id_idx on public.payment_requests(user_id);
create index if not exists payment_requests_status_idx on public.payment_requests(status);
create index if not exists payment_links_user_id_idx on public.payment_links(user_id);
create index if not exists payment_links_link_code_idx on public.payment_links(link_code);
create index if not exists contacts_user_id_idx on public.contacts(user_id);
create index if not exists transactions_user_id_idx on public.transactions(user_id);
create index if not exists transactions_tx_hash_idx on public.transactions(tx_hash);

-- Function to update updated_at timestamp
create or replace function public.handle_updated_at()
returns trigger as $$
begin
  new.updated_at = timezone('utc'::text, now());
  return new;
end;
$$ language plpgsql;

-- Trigger to auto-update updated_at
create trigger set_updated_at
  before update on public.profiles
  for each row
  execute function public.handle_updated_at();
[V0_FILE]typescriptreact:file="app/auth/login/loading.tsx" isFixed="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="components/qr-scanner.tsx" isMerged="true"
"use client"

import { useState, useRef, useEffect } from "react"
import { Card, CardContent } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { X } from "lucide-react"

interface QRScannerProps {
  onScan: (data: string) => void
  onClose: () => void
}

export function QRScanner({ onScan, onClose }: QRScannerProps) {
  const videoRef = useRef<HTMLVideoElement>(null)
  const canvasRef = useRef<HTMLCanvasElement>(null)
  const [stream, setStream] = useState<MediaStream | null>(null)
  const [error, setError] = useState<string | null>(null)
  const scanIntervalRef = useRef<NodeJS.Timeout | null>(null)

useEffect(() => {
    startCamera()
    return () => {
      stopCamera()
    }
  }, [])

const startCamera = async () => {
    try {
      const mediaStream = await navigator.mediaDevices.getUserMedia({
        video: { facingMode: "environment" },
      })
      setStream(mediaStream)
      if (videoRef.current) {
        videoRef.current.srcObject = mediaStream
        videoRef.current.play()
      }
      startScanning()
    } catch (err) {
      setError("Unable to access camera. Please allow camera permissions.")
      console.error("[v0] Camera access error:", err)
    }
  }

const stopCamera = () => {
    if (stream) {
      stream.getTracks().forEach((track) => track.stop())
    }
    if (scanIntervalRef.current) {
      clearInterval(scanIntervalRef.current)
    }
  }

const startScanning = () => {
    scanIntervalRef.current = setInterval(() => {
      scanQRCode()
    }, 500)
  }

const scanQRCode = async () => {
    if (!videoRef.current || !canvasRef.current) return

const video = videoRef.current
    const canvas = canvasRef.current
    const context = canvas.getContext("2d")

if (!context || video.readyState !== video.HAVE_ENOUGH_DATA) return

canvas.width = video.videoWidth
    canvas.height = video.videoHeight
    context.drawImage(video, 0, 0, canvas.width, canvas.height)

const imageData = context.getImageData(0, 0, canvas.width, canvas.height)

// Use jsQR library to detect QR code
    try {
      // @ts-ignore - jsQR is loaded via CDN
      const code = window.jsQR?.(imageData.data, imageData.width, imageData.height)
      if (code) {
        console.log("[v0] QR Code detected:", code.data)
        onScan(code.data)
        stopCamera()
      }
    } catch (err) {
      console.error("[v0] QR scanning error:", err)
    }
  }

return (
    <Card className="relative">
      <CardContent className="p-0">
        <div className="relative aspect-square bg-black rounded-lg overflow-hidden">
          {error ? (
            <div className="flex items-center justify-center h-full p-4 text-center">
              <p className="text-sm text-muted-foreground">{error}</p>
            </div>
          ) : (
            <>
              <video ref={videoRef} className="w-full h-full object-cover" playsInline />
              <canvas ref={canvasRef} className="hidden" />
              <div className="absolute inset-0 flex items-center justify-center pointer-events-none">
                <div className="border-2 border-white w-48 h-48 rounded-lg" />
              </div>
            </>
          )}
        </div>
        <Button onClick={onClose} variant="ghost" size="icon" className="absolute top-2 right-2">
          <X className="h-4 w-4" />
        </Button>
      </CardContent>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/branded-qr-code.tsx" isMerged="true"
"use client"

import { useRef, useEffect } from "react"
import QRCode from "qrcode"

interface BrandedQRCodeProps {
  value: string
  size?: number
  id?: string
}

export function BrandedQRCode({ value, size = 300, id }: BrandedQRCodeProps) {
  const canvasRef = useRef<HTMLCanvasElement>(null)

useEffect(() => {
    const generateQR = async () => {
      if (!canvasRef.current) return

const canvas = canvasRef.current
      const ctx = canvas.getContext("2d")
      if (!ctx) return

// Generate QR code
      await QRCode.toCanvas(canvas, value, {
        width: size,
        margin: 2,
        errorCorrectionLevel: "H", // High error correction to allow logo overlay
        color: {
          dark: "#000000",
          light: "#FFFFFF",
        },
      })

// Load and draw logo in center
      const logo = new Image()
      logo.crossOrigin = "anonymous"
      logo.src = "https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-Jq9cZRxin1Av9DnpNC34afsgfpBNAM.jpeg"

logo.onload = () => {
        const logoSize = size * 0.2 // Logo takes up 20% of QR code
        const logoX = (size - logoSize) / 2
        const logoY = (size - logoSize) / 2

// Draw white background for logo
        ctx.fillStyle = "white"
        ctx.fillRect(logoX - 8, logoY - 8, logoSize + 16, logoSize + 16)

// Draw logo
        ctx.drawImage(logo, logoX, logoY, logoSize, logoSize)
      }
    }

generateQR()
  }, [value, size])

return <canvas ref={canvasRef} id={id} width={size} height={size} className="rounded-lg" />
}
[V0_FILE]typescriptreact:file="app/auth/profile-setup/page.tsx" isMerged="true"
"use client"

export default function ProfileSetupPage() {
  const [username, setUsername] = useState("")
  const [displayName, setDisplayName] = useState("")
  const [walletAddress, setWalletAddress] = useState("")
  const [isChecking, setIsChecking] = useState(false)
  const [isAvailable, setIsAvailable] = useState<boolean | null>(null)
  const [isSaving, setIsSaving] = useState(false)
  const [user, setUser] = useState<any>(null)
  const supabase = createClient()

useEffect(() => {
    checkUser()
  }, [])

const checkUser = async () => {
    const {
      data: { user },
    } = await supabase.auth.getUser()
    if (!user) {
      window.location.href = "/auth/login"
      return
    }
    setUser(user)

const { data: profile } = await supabase.from("profiles").select("*").eq("id", user.id).single()

if (profile) {
      setUsername(profile.username)
      setDisplayName(profile.display_name || "")
      setWalletAddress(profile.wallet_address || "")
    }
  }

useEffect(() => {
    const checkUsername = async () => {
      if (username.length < 3) {
        setIsAvailable(null)
        return
      }

setIsChecking(true)
      // Use safe RPC (own-row RLS blocks reading other users' profiles directly)
      const { data } = await supabase.rpc("get_profile_by_username", { uname: username.toLowerCase() })

setIsAvailable(!data || data.length === 0)
      setIsChecking(false)
    }

const debounce = setTimeout(checkUsername, 500)
    return () => clearTimeout(debounce)
  }, [username, supabase])

const handleSave = async () => {
    if (!username || !walletAddress || isAvailable === false) return

setIsSaving(true)

const { error } = await supabase.from("profiles").upsert(
      {
        id: user.id,
        username: username.toLowerCase(),
        display_name: displayName || null,
        wallet_address: walletAddress,
      },
      { onConflict: "id" },
    )

if (error) {
      console.log("[v0] Profile save error:", error)
      alert("Error saving profile: " + error.message)
    } else {
      alert("Profile saved successfully!")
      window.location.href = "/"
    }

setIsSaving(false)
  }

return (
    <div className="min-h-screen bg-background p-4">
      <div className="max-w-md mx-auto py-8">
        <Button variant="ghost" onClick={() => window.history.back()} className="mb-4">
          <ArrowLeft className="h-4 w-4 mr-2" />
          Back
        </Button>

<Card>
          <CardHeader>
            <CardTitle>Complete Your Profile</CardTitle>
            <CardDescription>Set up your payment profile to start using PayPal-style features</CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="space-y-2">
              <Label>Username *</Label>
              <div className="relative">
                <Input
                  placeholder="johndoe"
                  value={username}
                  onChange={(e) => setUsername(e.target.value.toLowerCase().replace(/[^a-z0-9_]/g, ""))}
                  maxLength={20}
                />
                {isChecking && <div className="absolute right-3 top-3 text-muted-foreground">Checking...</div>}
                {!isChecking && isAvailable === true && (
                  <Check className="absolute right-3 top-3 h-4 w-4 text-green-500" />
                )}
                {!isChecking && isAvailable === false && <X className="absolute right-3 top-3 h-4 w-4 text-red-500" />}
              </div>
              <p className="text-xs text-muted-foreground">
                Your unique @username for receiving payments. Use letters, numbers, and underscores only.
              </p>
              {isAvailable === false && <p className="text-xs text-red-500">This username is already taken</p>}
            </div>

<div className="space-y-2">
              <Label>Display Name (Optional)</Label>
              <Input placeholder="John Doe" value={displayName} onChange={(e) => setDisplayName(e.target.value)} />
              <p className="text-xs text-muted-foreground">Your full name or business name</p>
            </div>

<div className="space-y-2">
              <Label>Wallet Address *</Label>
              <Input
                placeholder="0x..."
                value={walletAddress}
                onChange={(e) => setWalletAddress(e.target.value)}
                className="font-mono text-xs"
              />
              <p className="text-xs text-muted-foreground">The wallet address where you'll receive payments</p>
            </div>

<Button
              onClick={handleSave}
              disabled={!username || !walletAddress || isAvailable === false || isSaving}
              className="w-full"
            >
              {isSaving ? "Saving..." : "Save Profile"}
            </Button>
          </CardContent>
        </Card>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/unified-auth-modal.tsx" isMerged="true"
"use client"

import { useState } from "react"
import { createClient } from "@/lib/supabase/client"
import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"

interface UnifiedAuthModalProps {
  open: boolean
  onClose: () => void
  walletAddress: string
  onAuthComplete: () => void
}

export function UnifiedAuthModal({ open, onClose, walletAddress, onAuthComplete }: UnifiedAuthModalProps) {
  const [email, setEmail] = useState("")
  const [password, setPassword] = useState("")
  const [username, setUsername] = useState("")
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [message, setMessage] = useState("")
  const supabase = createClient()

const handleSignIn = async () => {
    setLoading(true)
    setError("")

const { data, error: signInError } = await supabase.auth.signInWithPassword({
      email,
      password,
    })

if (signInError) {
      setError(signInError.message)
      setLoading(false)
      return
    }

if (data.user) {
      // Link wallet address to profile
      await supabase.from("profiles").update({ wallet_address: walletAddress }).eq("id", data.user.id)

onAuthComplete()
      onClose()
    }

setLoading(false)
  }

const handleSignUp = async () => {
    if (!username) {
      setError("Username is required")
      return
    }

setLoading(true)
    setError("")
    setMessage("")

// Check if username is taken (safe RPC; own-row RLS blocks direct cross-user reads)
    const { data: existingUsers } = await supabase.rpc("get_profile_by_username", { uname: username })

if (existingUsers && existingUsers.length > 0) {
      setError("Username is already taken")
      setLoading(false)
      return
    }

const { data, error: signUpError } = await supabase.auth.signUp({
      email,
      password,
      options: {
        emailRedirectTo: process.env.NEXT_PUBLIC_DEV_SUPABASE_REDIRECT_URL || window.location.origin,
      },
    })

if (signUpError) {
      setError(signUpError.message)
      setLoading(false)
      return
    }

if (data.user) {
      // Create profile with username and wallet address
      await supabase.from("profiles").insert({
        id: data.user.id,
        username,
        wallet_address: walletAddress,
      })

setMessage("Account created! Please check your email to verify your account.")
      setTimeout(() => {
        onClose()
      }, 3000)
    }

setLoading(false)
  }

return (
    <Dialog open={open} onOpenChange={onClose}>
      <DialogContent className="sm:max-w-md">
        <DialogHeader>
          <DialogTitle>Enable Payment Features</DialogTitle>
          <DialogDescription>Sign in or create an account to use username-based payments</DialogDescription>
        </DialogHeader>

<Tabs defaultValue="signin" className="w-full">
          <TabsList className="grid w-full grid-cols-2">
            <TabsTrigger value="signin">Sign In</TabsTrigger>
            <TabsTrigger value="signup">Create Account</TabsTrigger>
          </TabsList>

<TabsContent value="signin" className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="signin-email">Email</Label>
              <Input
                id="signin-email"
                type="email"
                placeholder="you@example.com"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
              />
            </div>

<div className="space-y-2">
              <Label htmlFor="signin-password">Password</Label>
              <Input
                id="signin-password"
                type="password"
                value={password}
                onChange={(e) => setPassword(e.target.value)}
              />
            </div>

{error && <p className="text-sm text-red-500">{error}</p>}

<Button onClick={handleSignIn} disabled={loading || !email || !password} className="w-full">
              {loading ? "Signing in..." : "Sign In"}
            </Button>
          </TabsContent>

<TabsContent value="signup" className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="signup-username">Username *</Label>
              <div className="flex">
                <span className="inline-flex items-center px-3 rounded-l-md border border-r-0 border-input bg-muted text-muted-foreground">
                  @
                </span>
                <Input
                  id="signup-username"
                  placeholder="username"
                  value={username}
                  onChange={(e) => setUsername(e.target.value.toLowerCase().replace(/[^a-z0-9_]/g, ""))}
                  className="rounded-l-none"
                />
              </div>
            </div>

<div className="space-y-2">
              <Label htmlFor="signup-email">Email *</Label>
              <Input
                id="signup-email"
                type="email"
                placeholder="you@example.com"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
              />
            </div>

<div className="space-y-2">
              <Label htmlFor="signup-password">Password *</Label>
              <Input
                id="signup-password"
                type="password"
                value={password}
                onChange={(e) => setPassword(e.target.value)}
              />
            </div>

<p className="text-xs text-muted-foreground">
              Your wallet address will be linked to your account for seamless payments.
            </p>

{error && <p className="text-sm text-red-500">{error}</p>}
            {message && <p className="text-sm text-green-500">{message}</p>}

<Button onClick={handleSignUp} disabled={loading || !email || !password || !username} className="w-full">
              {loading ? "Creating account..." : "Create Account"}
            </Button>
          </TabsContent>
        </Tabs>
      </DialogContent>
    </Dialog>
  )
}
[V0_FILE]typescriptreact:file="app/social-post/page.tsx" isMerged="true"
export default function SocialPostPage() {
  return (
    <div className="min-h-screen bg-background p-8">
      <div className="mx-auto max-w-6xl space-y-8">
        <h1 className="text-3xl font-bold">LinkFiCrypto Social Media Assets</h1>
        
        <div className="grid gap-8 md:grid-cols-2">
          {/* Instagram Square Post */}
          <div className="space-y-4">
            <h2 className="text-xl font-semibold">Instagram Square (1080x1080)</h2>
            <div className="relative aspect-square overflow-hidden rounded-lg bg-black">
              <div className="flex h-full flex-col items-center justify-center p-12 text-white">
                <img 
                  src="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-vetPmP2ZWfrgG1gQYJbwrVK3ZgphSm.jpeg"
                  alt="LinkFiCrypto Logo"
                  className="mb-8 h-48 w-48 object-contain"
                />
                <h3 className="mb-4 text-center text-4xl font-bold">LiNKFiCRYPTO</h3>
                <p className="mb-6 text-center text-xl text-gray-300">The Future of Crypto Payments</p>
                <div className="flex gap-4 text-sm">
                  <span className="rounded-full bg-white/10 px-4 py-2">Send</span>
                  <span className="rounded-full bg-white/10 px-4 py-2">Receive</span>
                  <span className="rounded-full bg-white/10 px-4 py-2">Swap</span>
                </div>
                <p className="mt-8 text-sm text-gray-400">linkficrypto.com</p>
              </div>
            </div>
          </div>

{/* Twitter/X Post */}
          <div className="space-y-4">
            <h2 className="text-xl font-semibold">Twitter/X (1200x675)</h2>
            <div className="relative aspect-video overflow-hidden rounded-lg bg-black">
              <div className="flex h-full items-center justify-between p-12 text-white">
                <div className="flex-1">
                  <h3 className="mb-4 text-5xl font-bold">Simplify Your</h3>
                  <h3 className="mb-6 text-5xl font-bold">Crypto Life</h3>
                  <p className="mb-6 text-xl text-gray-300">
                    Send, receive, and swap crypto with ease
                  </p>
                  <p className="text-sm text-gray-400">linkficrypto.com</p>
                </div>
                <img 
                  src="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-vetPmP2ZWfrgG1gQYJbwrVK3ZgphSm.jpeg"
                  alt="LinkFiCrypto Logo"
                  className="h-40 w-40 object-contain"
                />
              </div>
            </div>
          </div>

{/* Instagram Story */}
          <div className="space-y-4">
            <h2 className="text-xl font-semibold">Instagram Story (1080x1920)</h2>
            <div className="relative mx-auto aspect-[9/16] w-full max-w-sm overflow-hidden rounded-lg bg-black">
              <div className="flex h-full flex-col items-center justify-center p-8 text-white">
                <img 
                  src="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-vetPmP2ZWfrgG1gQYJbwrVK3ZgphSm.jpeg"
                  alt="LinkFiCrypto Logo"
                  className="mb-12 h-64 w-64 object-contain"
                />
                <h3 className="mb-6 text-center text-5xl font-bold">LiNKFiCRYPTO</h3>
                <p className="mb-8 text-center text-2xl text-gray-300">
                  Your Non-Custodial
                  <br />
                  Crypto Wallet
                </p>
                <div className="space-y-4 text-lg">
                  <div className="flex items-center gap-3">
                    <div className="h-2 w-2 rounded-full bg-white"></div>
                    <span>Send to @username</span>
                  </div>
                  <div className="flex items-center gap-3">
                    <div className="h-2 w-2 rounded-full bg-white"></div>
                    <span>QR Code Payments</span>
                  </div>
                  <div className="flex items-center gap-3">
                    <div className="h-2 w-2 rounded-full bg-white"></div>
                    <span>Token Swaps</span>
                  </div>
                  <div className="flex items-center gap-3">
                    <div className="h-2 w-2 rounded-full bg-white"></div>
                    <span>Portfolio Analytics</span>
                  </div>
                </div>
                <p className="mt-12 text-sm text-gray-400">Swipe up to try it now</p>
              </div>
            </div>
          </div>

{/* LinkedIn Post */}
          <div className="space-y-4">
            <h2 className="text-xl font-semibold">LinkedIn (1200x627)</h2>
            <div className="relative aspect-[1.91/1] overflow-hidden rounded-lg bg-gradient-to-br from-black to-gray-900">
              <div className="flex h-full flex-col justify-between p-12 text-white">
                <img 
                  src="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0254-5ZuYaVInZd7xufYSEqTMIVKVr5WBJU.jpeg"
                  alt="LinkFiCrypto Full Logo"
                  className="h-16 object-contain object-left"
                />
                <div>
                  <h3 className="mb-4 text-4xl font-bold">Making Crypto Payments Simple</h3>
                  <p className="text-xl text-gray-300">
                    Experience the easiest way to manage your digital assets
                  </p>
                </div>
              </div>
            </div>
          </div>
        </div>

{/* Announcement Post */}
        <div className="space-y-4">
          <h2 className="text-xl font-semibold">Announcement Banner (1200x400)</h2>
          <div className="relative overflow-hidden rounded-lg bg-black">
            <div className="flex items-center justify-between p-12 text-white">
              <div className="flex items-center gap-8">
                <img 
                  src="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-vetPmP2ZWfrgG1gQYJbwrVK3ZgphSm.jpeg"
                  alt="LinkFiCrypto Logo"
                  className="h-24 w-24 object-contain"
                />
                <div>
                  <h3 className="mb-2 text-3xl font-bold">LiNKFiCRYPTO</h3>
                  <p className="text-lg text-gray-300">Now Live - Send Crypto Like Sending a Text</p>
                </div>
              </div>
              <div className="rounded-lg bg-white px-8 py-4 text-xl font-bold text-black">
                Try Now
              </div>
            </div>
          </div>
        </div>

{/* Download Instructions */}
        <div className="rounded-lg border border-border bg-card p-6">
          <h3 className="mb-4 text-lg font-semibold">How to Save These Posts</h3>
          <ol className="space-y-2 text-sm text-muted-foreground">
            <li>1. Right-click on any image above</li>
            <li>2. Select "Save Image As..." or take a screenshot</li>
            <li>3. Use for your social media platforms</li>
            <li>4. Recommended: Add your own call-to-action text when posting</li>
          </ol>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]jpeg:file="public/images/img-0254.jpeg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0254-5ZuYaVInZd7xufYSEqTMIVKVr5WBJU.jpeg" isMerged="true"
[V0_FILE]jpeg:file="public/images/img-0274.jpeg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0274-vetPmP2ZWfrgG1gQYJbwrVK3ZgphSm.jpeg" isMerged="true"
[V0_FILE]typescriptreact:file="lib/wallet-generator.ts" isMerged="true"
import { ethers } from 'ethers'

export interface GeneratedWallet {
  address: string
  privateKey: string
  mnemonic: string
}

/**
 * Generate a new Ethereum wallet
 */
export function generateWallet(): GeneratedWallet {
  const wallet = ethers.Wallet.createRandom()
  
  return {
    address: wallet.address,
    privateKey: wallet.privateKey,
    mnemonic: wallet.mnemonic?.phrase || '',
  }
}

/**
 * Recover wallet from mnemonic phrase
 */
export function recoverFromMnemonic(mnemonic: string): GeneratedWallet {
  const wallet = ethers.Wallet.fromPhrase(mnemonic)
  
  return {
    address: wallet.address,
    privateKey: wallet.privateKey,
    mnemonic: mnemonic,
  }
}

/**
 * Encrypt wallet data for secure storage
 */
export async function encryptWallet(wallet: GeneratedWallet, password: string): Promise<string> {
  const ethersWallet = new ethers.Wallet(wallet.privateKey)
  return await ethersWallet.encrypt(password)
}

/**
 * Decrypt wallet data
 */
export async function decryptWallet(encryptedJson: string, password: string): Promise<GeneratedWallet> {
  const wallet = await ethers.Wallet.fromEncryptedJson(encryptedJson, password)
  
  return {
    address: wallet.address,
    privateKey: wallet.privateKey,
    mnemonic: wallet.mnemonic?.phrase || '',
  }
}
[V0_FILE]sql:file="scripts/002_add_builtin_wallet_columns.sql" isEdit="true" isMerged="true"
-- Add columns to profiles table for built-in wallet
ALTER TABLE profiles 
ADD COLUMN IF NOT EXISTS encrypted_wallet text,
ADD COLUMN IF NOT EXISTS has_builtin_wallet boolean DEFAULT false,
ADD COLUMN IF NOT EXISTS builtin_wallet_address text;

-- Add index for faster lookups
CREATE INDEX IF NOT EXISTS idx_profiles_builtin_wallet 
ON profiles(builtin_wallet_address) 
WHERE builtin_wallet_address IS NOT NULL;
[V0_FILE]jpeg:file="public/images/img-0193.jpeg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/IMG_0193-FpoE5T04UZ55ZP8dDjFATC1hvQopXF.jpeg" isMerged="true"
[V0_FILE]typescriptreact:file="components/compliance-modal.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { AlertTriangle, CheckCircle2 } from "lucide-react"
import { Button } from "@/components/ui/button"
import { Checkbox } from "@/components/ui/checkbox"

export function ComplianceModal() {
  const [isOpen, setIsOpen] = useState(false)
  const [checkboxes, setCheckboxes] = useState({
    age: false,
    risks: false,
    cookies: false,
  })

useEffect(() => {
    if (typeof window === "undefined") return

const accepted = localStorage.getItem("compliance_accepted")
    if (!accepted) {
      setIsOpen(true)
    }
  }, [])

const allChecked = checkboxes.age && checkboxes.risks && checkboxes.cookies

const handleAccept = () => {
    if (!allChecked) return

localStorage.setItem("compliance_accepted", "true")
    localStorage.setItem("compliance_date", new Date().toISOString())
    setIsOpen(false)
  }

if (!isOpen) return null

return (
    <div className="absolute inset-0 flex items-center justify-center z-50 pointer-events-none">
      <div className="pointer-events-auto max-w-2xl mx-4 bg-background/98 backdrop-blur-md border-2 border-amber-500/50 rounded-lg shadow-2xl">
        <div className="p-6">
          <div className="flex items-start gap-3">
            <AlertTriangle className="w-6 h-6 text-amber-500 flex-shrink-0 mt-0.5" />

<div className="flex-1 space-y-4">
              <div>
                <h3 className="font-semibold text-base mb-2">Risk Acknowledgment Required</h3>
                <p className="text-sm text-muted-foreground">
                  Crypto is volatile and risky. By using LinkFiCrypto, you accept full responsibility for your
                  investment decisions.
                </p>
              </div>

<div className="space-y-3">
                <div className="flex items-start gap-3">
                  <Checkbox
                    id="age-compact"
                    checked={checkboxes.age}
                    onCheckedChange={(checked) => setCheckboxes({ ...checkboxes, age: checked as boolean })}
                    className="mt-0.5 border-2 border-primary data-[state=checked]:bg-primary data-[state=checked]:border-primary w-5 h-5"
                  />
                  <label htmlFor="age-compact" className="text-sm cursor-pointer leading-tight">
                    I'm 18+ and understand crypto risks including potential total loss
                  </label>
                </div>

<div className="flex items-start gap-3">
                  <Checkbox
                    id="risks-compact"
                    checked={checkboxes.risks}
                    onCheckedChange={(checked) => setCheckboxes({ ...checkboxes, risks: checked as boolean })}
                    className="mt-0.5 border-2 border-primary data-[state=checked]:bg-primary data-[state=checked]:border-primary w-5 h-5"
                  />
                  <label htmlFor="risks-compact" className="text-sm cursor-pointer leading-tight">
                    I agree to{" "}
                    <a href="/terms" className="text-primary hover:underline" target="_blank" rel="noreferrer">
                      Terms
                    </a>{" "}
                    &{" "}
                    <a href="/privacy" className="text-primary hover:underline" target="_blank" rel="noreferrer">
                      Privacy Policy
                    </a>
                  </label>
                </div>

<div className="flex items-start gap-3">
                  <Checkbox
                    id="cookies-compact"
                    checked={checkboxes.cookies}
                    onCheckedChange={(checked) => setCheckboxes({ ...checkboxes, cookies: checked as boolean })}
                    className="mt-0.5 border-2 border-primary data-[state=checked]:bg-primary data-[state=checked]:border-primary w-5 h-5"
                  />
                  <label htmlFor="cookies-compact" className="text-sm cursor-pointer leading-tight">
                    I accept the use of cookies and local storage for app functionality
                  </label>
                </div>
              </div>

<Button onClick={handleAccept} disabled={!allChecked} size="default" className="w-full">
                <CheckCircle2 className="w-4 h-4 mr-2" />
                Accept & Continue
              </Button>
            </div>
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]jpg:file="public/icon-192.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/attachments/gen-images/public/icon-192-3Ps7l55ldiRCSUzLurtxyuOzPprYst.jpg" isMerged="true"
[V0_FILE]jpg:file="public/icon-512.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/attachments/gen-images/public/icon-512-C85GETk82sglKbZ8TrIvEaO4zoaKMN.jpg" isMerged="true"
[V0_FILE]jpg:file="public/apple-touch-icon.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/attachments/gen-images/public/apple-touch-icon-ZfbXzZlONcXLEYZFotMUXpstNlE6GM.jpg" isMerged="true"
[V0_FILE]typescriptreact:file="lib/password-strength.ts" isMerged="true"
export interface PasswordStrength {
  score: number
  label: string
  color: string
  feedback: string[]
}

export function validatePasswordStrength(password: string): PasswordStrength {
  if (!password) {
    return {
      score: 0,
      label: "No password",
      color: "text-gray-500",
      feedback: ["Please enter a password"],
    }
  }

let score = 0
  const feedback: string[] = []

// Length check
  if (password.length >= 8) score++
  else feedback.push("Use at least 8 characters")

if (password.length >= 12) score++
  else if (password.length >= 8) feedback.push("Consider using 12+ characters for better security")

// Uppercase and lowercase
  if (/[a-z]/.test(password) && /[A-Z]/.test(password)) {
    score++
  } else {
    feedback.push("Include both uppercase and lowercase letters")
  }

// Numbers
  if (/\d/.test(password)) {
    score++
  } else {
    feedback.push("Include at least one number")
  }

// Special characters
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    score++
  } else {
    feedback.push("Include at least one special character (!@#$%^&*)")
  }

// Common patterns to avoid
  if (/^(password|12345|qwerty|abc123)/i.test(password)) {
    score = Math.max(0, score - 2)
    feedback.push("Avoid common passwords")
  }

// Sequential characters
  if (/(.)\1{2,}/.test(password)) {
    feedback.push("Avoid repeating characters")
  }

let label = "Weak"
  let color = "text-red-500"

if (score <= 2) {
    label = "Weak"
    color = "text-red-500"
  } else if (score <= 3) {
    label = "Fair"
    color = "text-orange-500"
  } else if (score <= 4) {
    label = "Good"
    color = "text-yellow-500"
  } else {
    label = "Strong"
    color = "text-green-500"
  }

return { score, label, color, feedback: feedback.slice(0, 3) }
}

export function isPasswordSecure(password: string): boolean {
  const strength = validatePasswordStrength(password)
  return strength.score >= 3
}
[V0_FILE]typescriptreact:file="components/payment-request.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import { createClient } from "@/lib/supabase/client"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"
import { Copy, Check, DollarSign, QrCodeIcon, Wallet, ChevronDown } from "lucide-react"
import { BrandedQRCode } from "@/components/branded-qr-code"

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface PaymentRequestProps {
  walletAddress: string
  connectedWallets?: ConnectedWallet[]
  activeWallet?: ConnectedWallet
  onSwitchWallet?: (wallet: ConnectedWallet) => void
}

export function PaymentRequest({ walletAddress, connectedWallets, activeWallet, onSwitchWallet }: PaymentRequestProps) {
  const [amount, setAmount] = useState("")
  const [token, setToken] = useState("ETH")
  const [note, setNote] = useState("")
  const [requestLink, setRequestLink] = useState("")
  const [copied, setCopied] = useState(false)
  const [isCreating, setIsCreating] = useState(false)
  const [showQR, setShowQR] = useState(false)
  const [showWalletSelector, setShowWalletSelector] = useState(false)
  const supabase = createClient()

const handleCreateRequest = async () => {
    if (!amount) return

setIsCreating(true)
    const {
      data: { user },
    } = await supabase.auth.getUser()

if (user) {
      const { data, error } = await supabase
        .from("payment_requests")
        .insert({
          user_id: user.id,
          recipient_wallet: walletAddress,
          amount: Number.parseFloat(amount),
          token,
          note,
          status: "pending",
        })
        .select()
        .single()

if (!error && data) {
        const link = `${window.location.origin}/pay/${data.id}`
        setRequestLink(link)
      }
    }

setIsCreating(false)
  }

const handleCopy = () => {
    navigator.clipboard.writeText(requestLink)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

return (
    <Card>
      <CardHeader>
        <div className="flex items-center justify-between">
          <div>
            <CardTitle>Request Payment</CardTitle>
            <CardDescription>Create a payment request link to share</CardDescription>
          </div>
          {connectedWallets && connectedWallets.length > 1 && activeWallet && onSwitchWallet && (
            <div className="relative">
              <Button
                variant="outline"
                size="default"
                onClick={() => setShowWalletSelector(!showWalletSelector)}
                className="gap-2 border-2 hover:border-primary/50"
              >
                <Wallet className="w-4 h-4" />
                <span className="font-mono font-semibold">
                  {activeWallet.address.slice(0, 6)}...{activeWallet.address.slice(-4)}
                </span>
                <ChevronDown className={`w-4 h-4 transition-transform ${showWalletSelector ? "rotate-180" : ""}`} />
              </Button>

{showWalletSelector && (
                <div className="absolute top-full right-0 mt-2 bg-card border-2 border-border rounded-lg shadow-xl z-10 min-w-[280px]">
                  <div className="p-2 space-y-1">
                    {connectedWallets.map((wallet) => (
                      <button
                        key={wallet.address}
                        onClick={() => {
                          onSwitchWallet(wallet)
                          setShowWalletSelector(false)
                        }}
                        className={`w-full p-3 rounded-lg flex items-center justify-between transition-colors ${
                          wallet.address === activeWallet.address
                            ? "bg-primary text-primary-foreground border-2 border-primary shadow-md"
                            : "hover:bg-accent border-2 border-transparent"
                        }`}
                      >
                        <div className="text-left">
                          <p className="font-semibold text-sm">{wallet.name}</p>
                          <p className="text-xs opacity-80 font-mono">
                            {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                          </p>
                        </div>
                        <p className="text-sm font-bold">{wallet.balance} ETH</p>
                      </button>
                    ))}
                  </div>
                </div>
              )}
            </div>
          )}
        </div>
      </CardHeader>
      <CardContent className="space-y-4">
        <div className="grid grid-cols-2 gap-4">
          <div className="space-y-2">
            <Label>Amount</Label>
            <Input
              type="number"
              placeholder="0.00"
              value={amount}
              onChange={(e) => setAmount(e.target.value)}
              step="0.000001"
            />
          </div>
          <div className="space-y-2">
            <Label>Token</Label>
            <select
              value={token}
              onChange={(e) => setToken(e.target.value)}
              className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
            >
              <option value="ETH">ETH</option>
              <option value="USDC">USDC</option>
              <option value="USDT">USDT</option>
            </select>
          </div>
        </div>

<div className="space-y-2">
          <Label>Description</Label>
          <Input placeholder="What's this payment for?" value={note} onChange={(e) => setNote(e.target.value)} />
        </div>

{!requestLink ? (
          <Button onClick={handleCreateRequest} disabled={!amount || isCreating} className="w-full">
            {isCreating ? (
              "Creating..."
            ) : (
              <>
                <DollarSign className="mr-2 h-4 w-4" />
                Create Payment Request
              </>
            )}
          </Button>
        ) : (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>Payment Request Link</Label>
              <div className="flex gap-2">
                <Input value={requestLink} readOnly className="font-mono text-xs" />
                <Button onClick={handleCopy} size="icon" variant="outline">
                  {copied ? <Check className="h-4 w-4" /> : <Copy className="h-4 w-4" />}
                </Button>
              </div>
              <p className="text-sm text-muted-foreground">
                Share this link to request {amount} {token}
              </p>
            </div>

<Button onClick={() => setShowQR(!showQR)} variant="outline" className="w-full">
              <QrCodeIcon className="mr-2 h-4 w-4" />
              {showQR ? "Hide" : "Show"} QR Code
            </Button>

{showQR && (
              <div className="flex justify-center p-6 bg-white rounded-lg">
                <BrandedQRCode value={requestLink} size={250} />
              </div>
            )}
          </div>
        )}
      </CardContent>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/payment-link-generator.tsx" isEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import { createClient } from "@/lib/supabase/client"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"
import { Copy, Check, QrCode, Link2, Download, Wallet, ChevronDown } from "lucide-react"
import { BrandedQRCode } from "@/components/branded-qr-code"

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface PaymentLinkGeneratorProps {
  walletAddress: string
  connectedWallets?: ConnectedWallet[]
  activeWallet?: ConnectedWallet
  onSwitchWallet?: (wallet: ConnectedWallet) => void
}

export function PaymentLinkGenerator({
  walletAddress,
  connectedWallets,
  activeWallet,
  onSwitchWallet,
}: PaymentLinkGeneratorProps) {
  const [amount, setAmount] = useState("")
  const [token, setToken] = useState("ETH")
  const [paymentLink, setPaymentLink] = useState("")
  const [copied, setCopied] = useState(false)
  const [showQR, setShowQR] = useState(false)
  const [isCreating, setIsCreating] = useState(false)
  const [showWalletSelector, setShowWalletSelector] = useState(false)
  const supabase = createClient()

const handleCreateLink = async () => {
    if (!amount) return

setIsCreating(true)
    const {
      data: { user },
    } = await supabase.auth.getUser()

if (user) {
      const linkCode = Math.random().toString(36).substring(2, 10)

const { data, error } = await supabase
        .from("payment_links")
        .insert({
          user_id: user.id,
          link_code: linkCode,
          title: "Store Payment",
          description: `Payment of ${amount} ${token}`,
          amount: Number.parseFloat(amount),
          token,
          is_active: true,
        })
        .select()
        .single()

if (!error && data) {
        const link = `${window.location.origin}/pay-link/${linkCode}`
        setPaymentLink(link)
      }
    }

setIsCreating(false)
  }

const handleCopy = () => {
    navigator.clipboard.writeText(paymentLink)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

const handleDownloadQR = () => {
    const canvas = document.getElementById("merchant-payment-qr") as HTMLCanvasElement
    if (!canvas) return

canvas.toBlob((blob) => {
      if (blob) {
        const url = URL.createObjectURL(blob)
        const link = document.createElement("a")
        link.download = `linkficrypto-payment-${Date.now()}.png`
        link.href = url
        link.click()
        URL.revokeObjectURL(url)
      }
    })
  }

return (
    <Card>
      <CardHeader>
        <div className="flex items-center justify-between">
          <div>
            <CardTitle>Pay at the Store</CardTitle>
            <CardDescription>Create a reusable payment link with QR code for easy in-person payments</CardDescription>
          </div>
          {connectedWallets && connectedWallets.length > 1 && activeWallet && onSwitchWallet && (
            <div className="relative">
              <Button
                variant="outline"
                size="default"
                onClick={() => setShowWalletSelector(!showWalletSelector)}
                className="gap-2 border-2 hover:border-primary/50"
              >
                <Wallet className="w-4 h-4" />
                <span className="font-mono font-semibold">
                  {activeWallet.address.slice(0, 6)}...{activeWallet.address.slice(-4)}
                </span>
                <ChevronDown className={`w-4 h-4 transition-transform ${showWalletSelector ? "rotate-180" : ""}`} />
              </Button>

{showWalletSelector && (
                <div className="absolute top-full right-0 mt-2 bg-card border-2 border-border rounded-lg shadow-xl z-10 min-w-[280px]">
                  <div className="p-2 space-y-1">
                    {connectedWallets.map((wallet) => (
                      <button
                        key={wallet.address}
                        onClick={() => {
                          onSwitchWallet(wallet)
                          setShowWalletSelector(false)
                        }}
                        className={`w-full p-3 rounded-lg flex items-center justify-between transition-colors ${
                          wallet.address === activeWallet.address
                            ? "bg-primary text-primary-foreground border-2 border-primary shadow-md"
                            : "hover:bg-accent border-2 border-transparent"
                        }`}
                      >
                        <div className="text-left">
                          <p className="font-semibold text-sm">{wallet.name}</p>
                          <p className="text-xs opacity-80 font-mono">
                            {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                          </p>
                        </div>
                        <p className="text-sm font-bold">{wallet.balance} ETH</p>
                      </button>
                    ))}
                  </div>
                </div>
              )}
            </div>
          )}
        </div>
      </CardHeader>
      <CardContent className="space-y-4">
        <div className="grid grid-cols-2 gap-4">
          <div className="space-y-2">
            <Label>Amount</Label>
            <Input
              type="number"
              placeholder="Enter amount"
              value={amount}
              onChange={(e) => setAmount(e.target.value)}
              step="0.000001"
              required
            />
          </div>
          <div className="space-y-2">
            <Label>Token</Label>
            <select
              value={token}
              onChange={(e) => setToken(e.target.value)}
              className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
            >
              <option value="ETH">ETH</option>
              <option value="USDC">USDC</option>
              <option value="USDT">USDT</option>
            </select>
          </div>
        </div>

{!paymentLink ? (
          <Button onClick={handleCreateLink} disabled={!amount || isCreating} className="w-full">
            {isCreating ? (
              "Creating..."
            ) : (
              <>
                <Link2 className="mr-2 h-4 w-4" />
                Generate Payment Link
              </>
            )}
          </Button>
        ) : (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>Your Payment Link</Label>
              <div className="flex gap-2">
                <Input value={paymentLink} readOnly className="font-mono text-xs" />
                <Button onClick={handleCopy} size="icon" variant="outline">
                  {copied ? <Check className="h-4 w-4" /> : <Copy className="h-4 w-4" />}
                </Button>
              </div>
            </div>

<Button onClick={() => setShowQR(!showQR)} variant="outline" className="w-full">
              <QrCode className="mr-2 h-4 w-4" />
              {showQR ? "Hide" : "Show"} QR Code
            </Button>

{showQR && (
              <div className="space-y-4">
                <div className="flex justify-center p-6 bg-white rounded-lg">
                  <BrandedQRCode value={paymentLink} size={250} id="merchant-payment-qr" />
                </div>
                <Button onClick={handleDownloadQR} variant="secondary" className="w-full">
                  <Download className="mr-2 h-4 w-4" />
                  Download QR Code
                </Button>
              </div>
            )}

<p className="text-sm text-muted-foreground">
              This link accepts {amount} {token} payments
            </p>
          </div>
        )}
      </CardContent>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/crypto-buy.tsx" isMerged="true"
"use client"

import { useState } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { CreditCard, DollarSign, AlertCircle } from "lucide-react"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface CryptoBuyProps {
  walletAddress: string
  connectedWallets: ConnectedWallet[]
  activeWallet: ConnectedWallet
  onSwitchWallet: (wallet: ConnectedWallet) => void
}

export function CryptoBuy({ walletAddress, connectedWallets, activeWallet, onSwitchWallet }: CryptoBuyProps) {
  const [amount, setAmount] = useState("")
  const [currency, setCurrency] = useState("USD")
  const [crypto, setCrypto] = useState("ETH")
  const [selectedWallet, setSelectedWallet] = useState(activeWallet.address)

const handleWalletChange = (address: string) => {
    const wallet = connectedWallets.find((w) => w.address === address)
    if (wallet) {
      setSelectedWallet(address)
      onSwitchWallet(wallet)
    }
  }

const handleBuy = () => {
    // Placeholder for buy crypto functionality
    alert(`Buy ${amount} ${currency} worth of ${crypto} functionality coming soon!`)
  }

const estimatedCrypto = amount ? (Number.parseFloat(amount) / 2500).toFixed(6) : "0.000000"

return (
    <div className="space-y-4">
      {connectedWallets.length > 1 && (
        <div className="space-y-2">
          <Label className="text-sm font-medium">Receiving Wallet</Label>
          <Select value={selectedWallet} onValueChange={handleWalletChange}>
            <SelectTrigger className="h-12 border-2 font-medium">
              <SelectValue />
            </SelectTrigger>
            <SelectContent>
              {connectedWallets.map((wallet) => (
                <SelectItem key={wallet.address} value={wallet.address}>
                  <div className="flex items-center gap-2">
                    <span className="font-semibold">{wallet.name}</span>
                    <span className="text-xs text-muted-foreground font-mono">
                      {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                    </span>
                    <span className="text-xs font-medium">({wallet.balance} ETH)</span>
                  </div>
                </SelectItem>
              ))}
            </SelectContent>
          </Select>
        </div>
      )}

<Card className="p-6 bg-gradient-to-br from-primary/5 to-success/5">
        <div className="space-y-4">
          <div className="space-y-2">
            <Label htmlFor="amount" className="text-sm font-medium">
              Amount to Spend
            </Label>
            <div className="relative">
              <DollarSign className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 text-muted-foreground" />
              <Input
                id="amount"
                type="number"
                placeholder="0.00"
                value={amount}
                onChange={(e) => setAmount(e.target.value)}
                className="pl-10 h-12 text-lg font-semibold border-2"
              />
              <Select value={currency} onValueChange={setCurrency}>
                <SelectTrigger className="absolute right-2 top-1/2 -translate-y-1/2 w-20 h-8 border-0 bg-accent">
                  <SelectValue />
                </SelectTrigger>
                <SelectContent>
                  <SelectItem value="USD">USD</SelectItem>
                  <SelectItem value="EUR">EUR</SelectItem>
                  <SelectItem value="GBP">GBP</SelectItem>
                </SelectContent>
              </Select>
            </div>
          </div>

<div className="space-y-2">
            <Label htmlFor="crypto" className="text-sm font-medium">
              Cryptocurrency
            </Label>
            <Select value={crypto} onValueChange={setCrypto}>
              <SelectTrigger className="h-12 border-2">
                <SelectValue />
              </SelectTrigger>
              <SelectContent>
                <SelectItem value="ETH">Ethereum (ETH)</SelectItem>
                <SelectItem value="BTC">Bitcoin (BTC)</SelectItem>
                <SelectItem value="USDC">USD Coin (USDC)</SelectItem>
                <SelectItem value="USDT">Tether (USDT)</SelectItem>
                <SelectItem value="DAI">Dai (DAI)</SelectItem>
              </SelectContent>
            </Select>
          </div>

{amount && (
            <Card className="p-4 bg-background border-2">
              <div className="flex items-center justify-between">
                <span className="text-sm text-muted-foreground">You will receive approximately</span>
                <span className="text-lg font-bold text-foreground">
                  {estimatedCrypto} {crypto}
                </span>
              </div>
            </Card>
          )}
        </div>
      </Card>

<Card className="p-4 bg-muted/50 border-warning/20">
        <div className="flex items-start gap-3">
          <AlertCircle className="w-5 h-5 text-warning flex-shrink-0 mt-0.5" />
          <div className="space-y-1">
            <p className="text-sm font-medium text-foreground">Third-Party Payment Gateway</p>
            <p className="text-xs text-muted-foreground">
              This feature uses a secure third-party payment processor. You'll be redirected to complete your purchase.
            </p>
          </div>
        </div>
      </Card>

<Button
        onClick={handleBuy}
        disabled={!amount || Number.parseFloat(amount) <= 0}
        className="w-full h-12 text-base font-semibold"
        size="lg"
      >
        <CreditCard className="w-5 h-5 mr-2" />
        Buy {crypto}
      </Button>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/crypto-swap.tsx" isMerged="true"
"use client"

import { useState } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { ArrowDownUp, AlertCircle } from "lucide-react"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface CryptoSwapProps {
  walletAddress: string
  connectedWallets: ConnectedWallet[]
  activeWallet: ConnectedWallet
  onSwitchWallet: (wallet: ConnectedWallet) => void
}

export function CryptoSwap({ walletAddress, connectedWallets, activeWallet, onSwitchWallet }: CryptoSwapProps) {
  const [fromAmount, setFromAmount] = useState("")
  const [fromToken, setFromToken] = useState("ETH")
  const [toToken, setToToken] = useState("USDC")
  const [selectedWallet, setSelectedWallet] = useState(activeWallet.address)

const handleSwap = () => {
    // Placeholder for swap functionality
    alert(`Swap ${fromAmount} ${fromToken} to ${toToken} functionality coming soon!`)
  }

const handleFlipTokens = () => {
    const temp = fromToken
    setFromToken(toToken)
    setToToken(temp)
  }

const estimatedToAmount = fromAmount ? (Number.parseFloat(fromAmount) * 2500).toFixed(2) : "0.00"

return (
    <div className="space-y-4">
      {connectedWallets.length > 1 && (
        <div className="space-y-2">
          <Label className="text-sm font-medium">Wallet</Label>
          <Select value={selectedWallet} onValueChange={handleWalletChange}>
            <SelectTrigger className="h-12 border-2 font-medium">
              <SelectValue />
            </SelectTrigger>
            <SelectContent>
              {connectedWallets.map((wallet) => (
                <SelectItem key={wallet.address} value={wallet.address}>
                  <div className="flex items-center gap-2">
                    <span className="font-semibold">{wallet.name}</span>
                    <span className="text-xs text-muted-foreground font-mono">
                      {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                    </span>
                    <span className="text-xs font-medium">({wallet.balance} ETH)</span>
                  </div>
                </SelectItem>
              ))}
            </SelectContent>
          </Select>
        </div>
      )}

<Card className="p-6 bg-gradient-to-br from-primary/5 to-success/5">
        <div className="space-y-4">
          <div className="space-y-2">
            <Label htmlFor="fromAmount" className="text-sm font-medium">
              You Pay
            </Label>
            <div className="flex gap-2">
              <Input
                id="fromAmount"
                type="number"
                placeholder="0.0"
                value={fromAmount}
                onChange={(e) => setFromAmount(e.target.value)}
                className="flex-1 h-12 text-lg font-semibold border-2"
              />
              <Select value={fromToken} onValueChange={setFromToken}>
                <SelectTrigger className="w-32 h-12 border-2 font-medium">
                  <SelectValue />
                </SelectTrigger>
                <SelectContent>
                  <SelectItem value="ETH">ETH</SelectItem>
                  <SelectItem value="USDC">USDC</SelectItem>
                  <SelectItem value="USDT">USDT</SelectItem>
                  <SelectItem value="DAI">DAI</SelectItem>
                  <SelectItem value="WBTC">WBTC</SelectItem>
                </SelectContent>
              </Select>
            </div>
            <p className="text-xs text-muted-foreground">Balance: {activeWallet.balance} ETH</p>
          </div>

<div className="space-y-2">
            <Label htmlFor="toAmount" className="text-sm font-medium">
              You Receive (Estimated)
            </Label>
            <div className="flex gap-2">
              <Input
                id="toAmount"
                type="text"
                placeholder="0.0"
                value={estimatedToAmount}
                readOnly
                className="flex-1 h-12 text-lg font-semibold border-2 bg-muted"
              />
              <Select value={toToken} onValueChange={setToToken}>
                <SelectTrigger className="w-32 h-12 border-2 font-medium">
                  <SelectValue />
                </SelectTrigger>
                <SelectContent>
                  <SelectItem value="ETH">ETH</SelectItem>
                  <SelectItem value="USDC">USDC</SelectItem>
                  <SelectItem value="USDT">USDT</SelectItem>
                  <SelectItem value="DAI">DAI</SelectItem>
                  <SelectItem value="WBTC">WBTC</SelectItem>
                </SelectContent>
              </Select>
            </div>
          </div>

{fromAmount && (
            <Card className="p-3 bg-background border-2">
              <div className="space-y-1 text-xs">
                <div className="flex justify-between">
                  <span className="text-muted-foreground">Exchange Rate</span>
                  <span className="font-medium">
                    1 {fromToken} = 2,500 {toToken}
                  </span>
                </div>
                <div className="flex justify-between">
                  <span className="text-muted-foreground">Network Fee</span>
                  <span className="font-medium">~$5.00</span>
                </div>
              </div>
            </Card>
          )}
        </div>
      </Card>

<Card className="p-4 bg-muted/50 border-warning/20">
        <div className="flex items-start gap-3">
          <AlertCircle className="w-5 h-5 text-warning flex-shrink-0 mt-0.5" />
          <div className="space-y-1">
            <p className="text-sm font-medium text-foreground">Decentralized Exchange</p>
            <p className="text-xs text-muted-foreground">
              Swaps are executed on-chain. Prices may vary based on market conditions and liquidity.
            </p>
          </div>
        </div>
      </Card>

<Button
        onClick={handleSwap}
        disabled={!fromAmount || Number.parseFloat(fromAmount) <= 0}
        className="w-full h-12 text-base font-semibold"
        size="lg"
      >
        <ArrowDownUp className="w-5 h-5 mr-2" />
        Swap Tokens
      </Button>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/wallet-history.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Clock, Trash2 } from "lucide-react"
import type { JSX } from "react"
import { useState, useEffect } from "react"

interface WalletHistoryItem {
  address: string
  provider: string
  name: string
  lastConnected: number
}

interface WalletHistoryProps {
  onReconnect: (provider: string, address: string) => void
  onClearHistory: () => void
  onRemoveItem: (address: string) => void
}

export function WalletHistory({ onReconnect, onClearHistory, onRemoveItem }: WalletHistoryProps) {
  const [history, setHistory] = useState<WalletHistoryItem[]>([])
  const [isLoading, setIsLoading] = useState(true)

useEffect(() => {
    console.log("[v0] ===== WalletHistory useEffect START =====")
    loadHistory()
  }, [])

const loadHistory = () => {
    console.log("[v0] loadHistory called")

if (typeof window === "undefined") {
      console.log("[v0] Window undefined, cannot load history")
      setIsLoading(false)
      return
    }

try {
      const HISTORY_KEY = "wallet_history"
      const historyData = localStorage.getItem(HISTORY_KEY)
      console.log("[v0] Loading history from localStorage with key:", HISTORY_KEY)
      console.log("[v0] Raw localStorage data:", historyData)

if (historyData) {
        const parsed = JSON.parse(historyData)
        console.log("[v0] Parsed history:", parsed)
        console.log("[v0] History length:", parsed.length)
        setHistory(parsed)
      } else {
        console.log("[v0] No history found in localStorage")
        setHistory([])
      }
    } catch (error) {
      console.error("[v0] Error loading history:", error)
      console.error("[v0] Error stack:", error instanceof Error ? error.stack : "No stack trace")
      setHistory([])
    } finally {
      setIsLoading(false)
      console.log("[v0] ===== WalletHistory useEffect END =====")
    }
  }

const getWalletLogo = (provider: string) => {
    const logos: Record<string, JSX.Element> = {
      metamask: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <path fill="#E17726" d="M32.96 3.08l-11.31 8.4 2.09-4.97z" />
          <path
            fill="#E27625"
            d="M7.04 3.08l11.2 8.47-1.98-5.04zM28.13 27.74l-3 4.6 6.42 1.77 1.84-6.3zM3.63 27.81l1.83 6.3 6.42-1.77-3-4.6z"
          />
          <path
            fill="#E27625"
            d="M11.41 17.51l-1.77 2.67 6.37.29-.21-6.85zM28.59 17.51l-4.46-4-.14 6.96 6.37-.29zM11.88 32.34l3.83-1.87-3.3-2.58zM24.29 30.47l3.83 1.87-.53-4.45z"
          />
          <path fill="#D5BFB2" d="M28.12 32.34l-3.83-1.87.31 2.48-.03 1.03zM11.88 32.34l3.55 1.64-.02-1.03.29-2.48z" />
          <path fill="#233447" d="M15.49 24.91l-3.18-.94 2.25-1.03zM24.51 24.91l.93-1.97 2.26 1.03z" />
          <path
            fill="#CC6228"
            d="M11.88 32.34l.55-4.6-3.55.1zM27.57 27.74l.55 4.6 3-4.5zM30.36 20.18l-6.37.29.59 3.28.93-1.97 2.26 1.03zM12.31 22.97l2.25-1.03.93 1.97.59-3.28-6.37-.29z"
          />
          <path
            fill="#E27525"
            d="M9.71 20.18l2.69 5.25-.09-2.61zM27.77 22.82l-.11 2.61 2.7-5.25zM16.08 20.47l-.59 3.28.74 3.82.17-5.03zM23.99 20.47l-.32 2.06.15 5.04.75-3.82z"
          />
          <path
            fill="#F5841F"
            d="M24.58 24.91l-.75 3.82.54.37 3.3-2.58.11-2.61zM12.31 22.97l.09 2.61 3.3 2.58.54-.37-.74-3.82z"
          />
          <path
            fill="#C0AC9D"
            d="M24.65 33.98l.03-1.03-.28-.24h-4.12l-.26.24.02 1.03-3.55-1.64 1.24 1.02 2.52 1.74h4.18l2.53-1.74 1.24-1.02z"
          />
          <path fill="#161616" d="M24.29 30.47l-.54-.37h-3.18l-.54.37-.29 2.48.26-.24h4.12l.28.24z" />
          <path
            fill="#763E1A"
            d="M33.36 12.13l.94-4.53-1.4-4.18-10.61 7.88 4.08 3.45 5.77 1.68 1.27-1.48-.55-.4.88-.8-.68-.52.88-.67zM5.7 7.6l.94 4.53-.59.43.88.67-.67.52.88.8-.55.4 1.27 1.48 5.77-1.68 4.08-3.45L6.1 3.42z"
          />
          <path
            fill="#F5841F"
            d="M31.91 19.31l-5.77-1.68 1.77 2.67-2.7 5.25 3.56-.05h5.31zM13.86 17.63l-5.77 1.68-2.38 6.24h5.31l3.54.05-2.7-5.25zM23.99 20.47l.37-6.42 1.68-4.54h-7.46l1.66 4.54.37 6.42.14 2.08.01 5.01h3.18l.01-5.01z"
          />
        </svg>
      ),
      coinbase: (
        <svg viewBox="0 0 1024 1024" className="w-full h-full">
          <rect width="1024" height="1024" rx="180" fill="#0052FF" />
          <path fill="white" d="M312 312h400v400H312z" />
        </svg>
      ),
      trust: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="trustGradientHistory" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#3375BB" />
              <stop offset="100%" stopColor="#3375BB" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#trustGradientHistory)" />
          <path
            fill="#FFF"
            d="M20 8l-8 4v8c0 5 3.5 9.5 8 11 4.5-1.5 8-6 8-11v-8l-8-4zm0 3.5l5.5 2.75v6.75c0 3.5-2.5 7-5.5 8.25-3-1.25-5.5-4.75-5.5-8.25v-6.75L20 11.5z"
          />
        </svg>
      ),
      walletconnect: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#3B99FC" />
          <path
            fill="#FFF"
            d="M12.5 15.5c4.5-4.4 11.8-4.4 16.3 0l.5.5c.2.2.2.6 0 .8l-1.8 1.8c-.1.1-.3.1-.4 0l-.7-.7c-3.1-3.1-8.2-3.1-11.4 0l-.8.8c-.1.1-.2.1-.2 0l-1.8-1.8c-.2-.2-.2-.6 0-.8l.5-.6zm20.1 3.7l1.6 1.6c.2.2.2.6 0 .8l-7.3 7.2c-.2.2-.6.2-.8 0l-5.2-5.1c-.1-.1-.2-.1-.2 0l-5.2 5.1c-.2.2-.6.2-.8 0l-7.3-7.2c-.2-.2-.2-.6 0-.8l1.6-1.6c.2-.2.6-.2.8 0z"
          />
        </svg>
      ),
      anyweb3: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#627EEA" />
          <path fill="#FFF" fillOpacity="0.6" d="M20 4l-.3.9v20.8l.3.3 9.2-5.4z" />
          <path fill="#FFF" d="M20 4l-9.2 16.6L20 26z" />
          <path fill="#FFF" fillOpacity="0.6" d="M20 28.3l-.2.2v7.1l.2.6 9.2-13z" />
          <path fill="#FFF" d="M20 36.2v-7.9l-9.2-5.4z" />
          <path fill="#FFF" fillOpacity="0.2" d="M20 26l9.2-5.4L20 14.3z" />
          <path fill="#FFF" fillOpacity="0.6" d="M10.8 20.6L20 26V14.3z" />
        </svg>
      ),
    }
    return logos[provider] || logos.anyweb3
  }

const formatDate = (timestamp: number) => {
    const date = new Date(timestamp)
    const now = new Date()
    const diffMs = now.getTime() - date.getTime()
    const diffMins = Math.floor(diffMs / 60000)
    const diffHours = Math.floor(diffMs / 3600000)
    const diffDays = Math.floor(diffMs / 86400000)

if (diffMins < 1) return "Just now"
    if (diffMins < 60) return `${diffMins}m ago`
    if (diffHours < 24) return `${diffHours}h ago`
    if (diffDays < 7) return `${diffDays}d ago`
    return date.toLocaleDateString()
  }

return (
    <Card className="p-6 bg-card border-border mb-6">
      <div className="flex items-center justify-between mb-4">
        <div className="flex items-center gap-2">
          <Clock className="w-5 h-5 text-muted-foreground" />
          <h3 className="text-lg font-semibold text-foreground">Recent Wallets</h3>
          <span className="text-xs text-muted-foreground">({history.length})</span>
        </div>
        {history.length > 0 && (
          <Button
            variant="ghost"
            size="sm"
            onClick={() => {
              onClearHistory()
              setHistory([])
            }}
            className="text-muted-foreground hover:text-destructive"
          >
            <Trash2 className="w-4 h-4 mr-2" />
            Clear All
          </Button>
        )}
      </div>

{isLoading ? (
        <div className="text-center py-8">
          <p className="text-muted-foreground">Loading history...</p>
        </div>
      ) : history.length === 0 ? (
        <div className="text-center py-8">
          <p className="text-muted-foreground">No wallet history yet</p>
          <p className="text-sm text-muted-foreground mt-2">
            Connect a wallet below to see it here for quick reconnection
          </p>
        </div>
      ) : (
        <div className="space-y-3">
          {history.map((item) => (
            <div
              key={item.address}
              className="flex items-center justify-between p-4 rounded-lg border border-border bg-background hover:bg-accent transition-colors"
            >
              <div className="flex items-center gap-4 flex-1">
                <div className="w-12 h-12 rounded-full bg-card flex items-center justify-center shadow-sm flex-shrink-0">
                  {getWalletLogo(item.provider)}
                </div>
                <div className="flex-1 min-w-0">
                  <p className="font-semibold text-foreground">{item.name}</p>
                  <p className="text-sm text-muted-foreground font-mono truncate">
                    {item.address.slice(0, 10)}...{item.address.slice(-8)}
                  </p>
                  <p className="text-xs text-muted-foreground mt-1">{formatDate(item.lastConnected)}</p>
                </div>
              </div>
              <div className="flex items-center gap-2">
                <Button
                  variant="outline"
                  size="sm"
                  onClick={() => onReconnect(item.provider, item.address)}
                  className="whitespace-nowrap"
                >
                  Reconnect
                </Button>
                <Button
                  variant="ghost"
                  size="sm"
                  onClick={() => {
                    onRemoveItem(item.address)
                    setHistory((prev) => prev.filter((h) => h.address !== item.address))
                  }}
                  className="h-9 w-9 p-0 hover:bg-destructive/10"
                >
                  <Trash2 className="w-4 h-4 text-muted-foreground hover:text-destructive" />
                </Button>
              </div>
            </div>
          ))}
        </div>
      )}
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/wallet-connect.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { Wallet, Loader2, X } from "lucide-react"
import type { JSX } from "react/jsx-runtime"
import { BuiltInWallet } from "@/components/built-in-wallet"

interface WalletConnectProps {
  onConnect: (wallet: ConnectedWallet) => void
  connectedWallets: ConnectedWallet[]
  isOpen?: boolean
  onClose?: () => void
}

interface WalletOption {
  id: WalletProvider
  name: string
  icon: string
  available: boolean
  downloadUrl: string
  deepLink?: string
}

interface ConnectedWallet {
  address: string
  balance: string
  provider: WalletProvider
  name: string
}

export function WalletConnect({ onConnect, connectedWallets, isOpen: externalIsOpen, onClose }: WalletConnectProps) {
  const [isConnecting, setIsConnecting] = useState(false)
  const [error, setError] = useState<string>("")
  const [showWalletModal, setShowWalletModal] = useState(false)
  const [connectingWallet, setConnectingWallet] = useState<string>("")
  const [hasBuiltInWallet, setHasBuiltInWallet] = useState(false)

useEffect(() => {
    const checkBuiltInWallet = () => {
      const hasWallet = connectedWallets.some((w) => w.provider === "builtin")
      setHasBuiltInWallet(hasWallet)
    }

checkBuiltInWallet()
  }, [connectedWallets])

const isMobile = () => {
    if (typeof window === "undefined") return false
    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
  }

const getWalletLogo = (id: WalletProvider) => {
    const logos: Record<WalletProvider, JSX.Element> = {
      metamask: (
        <svg viewBox="0 0 318.6 318.6" className="w-full h-full">
          <path
            fill="#E2761B"
            stroke="#E2761B"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M274.1 35.5L174.6 109.4 193 65.8z"
          />
          <path
            fill="#E4761B"
            stroke="#E4761B"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M44.4 35.5l99.9 74.6-17.9-43.3zm193.9 171.3l-26.5 40.6 56.7 15.6 16.3-55.3zm-204.4.9L50.1 263l56.7-15.6-26.5-40.6z"
          />
          <path
            fill="#E4761B"
            stroke="#E4761B"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M103.6 138.2l-16.2 24.6 56.3 2.5-2-60.5zm111.3 0l-39-34.8-1.3 61.2 56.2-2.5zM106.8 247.4l33.8-16.5-29.2-22.8zm71.1-16.5l33.9 16.5-4.7-39.3z"
          />
          <path
            fill="#D7C1B3"
            stroke="#D7C1B3"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M211.8 247.4l-33.9-16.5 2.7 22.1-.3 9.3zm-105 0l31.5 14.9-.2-9.3 2.5-22.1z"
          />
          <path
            fill="#233447"
            stroke="#233447"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M138.8 193.5l-28.2-8.3 19.9-9.1zm40.9 0l8.3-17.4 20 9.1z"
          />
          <path
            fill="#CD6116"
            stroke="#CD6116"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M106.8 247.4l4.8-40.6-31.3.9zM207 206.8l4.8 40.6 26.5-39.7zm23.8-44.7l-56.2 2.5 5.2 28.9 8.3-17.4 20 9.1zm-120.2 23.1l20-9.1 8.2 17.4 5.3-28.9-56.3-2.5z"
          />
          <path
            fill="#E4751F"
            stroke="#E4751F"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M87.8 162.1l23.6 46-.8-22.9zm120.3 23.1l-1 22.9 23.7-46zm-64-20.6l-5.3 28.9 6.6 34.1 1.5-44.9zm30.5 0l-2.7 18 1.2 45 6.7-34.1z"
          />
          <path
            fill="#F6851B"
            stroke="#F6851B"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M179.8 193.5l-6.7 34.1 4.8 3.3 29.2-22.8 1-22.9zm-69.2-8.3l.8 22.9 29.2 22.8 4.8-3.3-6.6-34.1z"
          />
          <path
            fill="#C0AD9E"
            stroke="#C0AD9E"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M180.3 262.3l.3-9.3-2.5-2.2h-37.7l-2.3 2.2.2 9.3-31.5-14.9 11 9 22.3 15.5h38.3l22.4-15.5 11-9z"
          />
          <path
            fill="#161616"
            stroke="#161616"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M177.9 230.9l-4.8-3.3h-27.7l-4.8 3.3-2.5 22.1 2.3-2.2h37.7l2.5 2.2z"
          />
          <path
            fill="#763D16"
            stroke="#763D16"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M278.3 114.2l8.5-40.8-12.7-37.9-96.2 71.4 37 31.3 52.3 15.3 11.6-13.5-5-3.6 8-7.3-6.2-4.8 8-6.1zM31.8 73.4l8.5 40.8-5.4 4 8 6.1-6.1 4.8 8 7.3-5 3.6 11.5 13.5 52.3-15.3 37-31.3-96.2-71.4z"
          />
          <path
            fill="#F6851B"
            stroke="#F6851B"
            strokeLinecap="round"
            strokeLinejoin="round"
            d="M267.2 153.5l-52.3-15.3 15.9 23.9-23.7 46 31.2-.4h46.5zm-163.6-15.3l-52.3 15.3-17.4 54.2h46.4l31.1.4-23.6-46zm71 26.4l3.3-57.7 15.2-41.1h-67.5l15 41.1 3.5 57.7 1.2 18.2.1 44.8h27.7l.2-44.8z"
          />
        </svg>
      ),
      coinbase: (
        <svg viewBox="0 0 24 24" className="w-full h-full">
          <rect width="24" height="24" fill="white" rx="4" />
          <rect x="4" y="4" width="16" height="16" fill="#0052FF" rx="2" />
        </svg>
      ),
      trust: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="trustGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#3375BB" />
              <stop offset="100%" stopColor="#3375BB" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#trustGradient)" />
          <path
            fill="#FFF"
            d="M20 8l-8 4v8c0 5 3.5 9.5 8 11 4.5-1.5 8-6 8-11v-8l-8-4zm0 3.5l5.5 2.75v6.75c0 3.5-2.5 7-5.5 8.25-3-1.25-5.5-4.75-5.5-8.25v-6.75L20 11.5z"
          />
        </svg>
      ),
      walletconnect: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#3B99FC" />
          <path
            fill="#FFF"
            d="M12.5 15.5c4.5-4.4 11.8-4.4 16.3 0l.5.5c.2.2.2.6 0 .8l-1.8 1.8c-.1.1-.3.1-.4 0l-.7-.7c-3.1-3.1-8.2-3.1-11.4 0l-.8.8c-.1.1-.2.1-.2 0l-1.8-1.8c-.2-.2-.2-.6 0-.8l.5-.6zm20.1 3.7l1.6 1.6c.2.2.2.6 0 .8l-7.3 7.2c-.2.2-.6.2-.8 0l-5.2-5.1c-.1-.1-.2-.1-.2 0l-5.2 5.1c-.2.2-.6.2-.8 0l-7.3-7.2c-.2-.2-.2-.6 0-.8l1.6-1.6c.2-.2.6-.2.8 0l5.2 5.1c.1.1.2.1.2 0l5.2-5.1c.2-.2.6-.2.8 0l5.2 5.1c.1.1.2.1.2 0l5.2-5.1c.2-.2.6-.2.8 0z"
          />
        </svg>
      ),
      phantom: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="phantomGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#AB9FF2" />
              <stop offset="100%" stopColor="#4E44CE" />
            </linearGradient>
          </defs>
          <rect width="40" height="40" rx="8" fill="url(#phantomGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12v8c0 2.2 1.8 4 4 4h16c2.2 0 4-1.8 4-4v-8c0-6.6-5.4-12-12-12zm-4 14c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"
          />
        </svg>
      ),
      rainbow: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="rainbowGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#FF6B6B" />
              <stop offset="25%" stopColor="#FFD93D" />
              <stop offset="50%" stopColor="#6BCF7F" />
              <stop offset="75%" stopColor="#4D96FF" />
              <stop offset="100%" stopColor="#9B59B6" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#rainbowGradient)" />
          <path
            fill="#FFF"
            d="M20 10c-5.5 0-10 4.5-10 10h4c0-3.3 2.7-6 6-6s6 2.7 6 6h4c0-5.5-4.5-10-10-10zm0 6c-2.2 0-4 1.8-4 4h8c0-2.2-1.8-4-4-4s-4 2.7-4 4z"
          />
        </svg>
      ),
      brave: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#FB542B" />
          <path
            fill="#FFF"
            d="M20 6l-2 4-4 2 4 2 2 4 2-4 4-2-4-2-2-4zm-8 12l-2 4 2 4 4-2 2-4-2-4-4 2zm16 0l-4 2-2 4 2 4 4 2 2-4-2-4zm-8 8l-2 4 2 4 2-4-2-4z"
          />
        </svg>
      ),
      rabby: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="rabbyGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#8697FF" />
              <stop offset="100%" stopColor="#7084FF" />
            </linearGradient>
          </defs>
          <rect width="40" height="40" rx="8" fill="url(#rabbyGradient)" />
          <path
            fill="#FFF"
            d="M12 16c0-2 1-4 3-5l2 3c-1 .5-1.5 1.5-1.5 2.5v3c0 1 .5 2 1.5 2.5l-2 3c-2-1-3-3-3-5v-4zm16 0c0-2-1-4-3-5l-2 3c1 .5 1.5 1.5 1.5 2.5v3c0 1-.5 2-1.5 2.5l2 3c2-1 3-3 3-5v-4zm-8-4c-1.5 0-2.5 1-2.5 2.5v11c0 1.5 1 2.5 2.5 2.5s2.5-1 2.5-2.5v-11c0-1.5-1-2.5-2.5-2.5z"
          />
        </svg>
      ),
      zerion: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="zerionGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#2962EF" />
              <stop offset="100%" stopColor="#1E4FCD" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#zerionGradient)" />
          <path
            fill="#FFF"
            d="M28 12l-8 8 8 8h-4l-8-8 8-8h4zm-12 0l-4 4 4 4 4-4-4-4zm0 8l-4 4 4 4 4-4-4-4zm0 4l-4 4 4 4 4-4-4-4z"
          />
        </svg>
      ),
      okx: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <rect width="40" height="40" fill="#000" />
          <path fill="#FFF" d="M12 12h6v6h-6v-6zm10 0h6v6h-6v-6zm-10 10h6v6h-6v-6zm10 0h6v6h-6v-6z" />
        </svg>
      ),
      binance: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#F3BA2F" />
          <path
            fill="#FFF"
            d="M20 14l-2 2-2-2-2 2 4 4 4-4 2-2zm-6 6l-2 2 2 2 2-2-2-2zm0 0l-2 2 2 2 2-2-2-2zm0 0l-2 2 2 2 2-2-2-2zm-6 6l-2 2 2 2 2-2-2-2z"
          />
        </svg>
      ),
      cryptocom: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="cryptocomGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#103F68" />
              <stop offset="100%" stopColor="#0B2A45" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#cryptocomGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12s5.4 12 12 12 12-5.4 12-12-5.4-12-12-12zm-4 18c-2.2 0-4-1.8-4-4s1.8-4 4-4c1.1 0 2.1.4 2.8 1.2l-1.4 1.4c-.4-.4-.9-.6-1.4-.6-1.1 0-2 .9-2 2s.9 2 2 2c.5 0 1-.2 1.4-.6l1.4 1.4c-.7.8-1.7 1.2-2.8 1.2zm8 0c-2.2 0-4-1.8-4-4s1.8-4 4-4c1.1 0 2.1.4 2.8 1.2l-1.4 1.4c-.4-.4-.9-.6-1.4-.6-1.1 0-2 .9-2 2s.9 2 2 2c.5 0 1-.2 1.4-.6l1.4 1.4c-.7.8-1.7 1.2-2.8 1.2z"
          />
        </svg>
      ),
      imtoken: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="imtokenGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#11C4D1" />
              <stop offset="100%" stopColor="#0062AD" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#imtokenGradient)" />
          <path fill="#FFF" d="M20 8l-8 8v8l8 8 8-8v-8l-8-8zm0 4l4 4v4l-4 4-4-4v-4l4-4z" />
        </svg>
      ),
      tokenpocket: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="tokenpocketGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#2980FE" />
              <stop offset="100%" stopColor="#2980FE" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#tokenpocketGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12s5.4 12 12 12 12-5.4 12-12-5.4-12-12-12zm-2 18v-12l8 6-8 6v12z"
          />
        </svg>
      ),
      mathwallet: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <rect width="40" height="40" fill="#000" />
          <path
            fill="#FFF"
            d="M12 12h4v4h-4v-4zm6 0h4v4h-4v-4zm6 0h4v4h-4v-4zm-12 6h4v4h-4v-4zm6 0h4v4h-4v-4zm6 0h4v4h-4v-4zm-12 6h4v4h-4v-4zm6 0h4v4h-4v-4zm6 0h4v4h-4v-4z"
          />
        </svg>
      ),
      safepal: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="safepalGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#6C5CE7" />
              <stop offset="100%" stopColor="#5F3DC4" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#safepalGradient)" />
          <path
            fill="#FFF"
            d="M20 8l-8 4v8c0 5 3.5 9.5 8 11 4.5-1.5 8-6 8-11v-8l-8-4zm0 3.5l5.5 2.75v6.75c0 3.5-2.5 7-5.5 8.25-3-1.25-5.5-4.75-5.5-8.25v-6.75L20 11.5zm-2 8.5l-2-2-1.5 1.5 3.5 3.5 7-7-1.5-1.5-5.5 5.5z"
          />
        </svg>
      ),
      bitget: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="bitgetGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#00F0FF" />
              <stop offset="100%" stopColor="#5200FF" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#bitgetGradient)" />
          <path fill="#FFF" d="M20 8l-8 8 8 8 8-8-8-8zm0 4l4 4-4 4-4-4 4-4zm-8 12l8 8 8-8v4l-8 4-8-4v-4z" />
        </svg>
      ),
      gateio: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="gateioGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#2354E6" />
              <stop offset="100%" stopColor="#1A3FB7" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#gateioGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12s5.4 12 12 12 12-5.4 12-12-5.4-12-12-12zm-6 12c0-3.3 2.7-6 6-6v4c-1.1 0-2 .9-2 2s.9 2 2 2v4c-3.3 0-6-2.7-6-6zm12 0c0 3.3-2.7 6-6 6v-4c1.1 0 2-.9 2-2s-.9-2-2-2v-4c3.3 0 6 2.7 6 6z"
          />
        </svg>
      ),
      exodus: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="exodusGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#0B46F9" />
              <stop offset="100%" stopColor="#BFDBFE" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#exodusGradient)" />
          <path fill="#FFF" d="M20 8l-8 4v8l8 4 8-4v-8l-8-4zm0 4l4 2v4l-4 2-4-2v-4l4-2zm-8 12l8 4 8-4v4l-8 4-8-4v-4z" />
        </svg>
      ),
      enkrypt: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="enkryptGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#E74C3C" />
              <stop offset="100%" stopColor="#C0392B" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#enkryptGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12s5.4 12 12 12 12-5.4 12-12-5.4-12-12-12zm-4 8h8v2h-8v-2zm0 4h8v2h-8v-2zm0 4h8v2h-8v-2z"
          />
        </svg>
      ),
      frame: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <rect width="40" height="40" fill="#000" />
          <path fill="#FFF" d="M8 8h24v24H8V8zm14 0h10v10H22V8zM8 22h10v10H8V22zm14 0h10v10H22V22z" />
        </svg>
      ),
      taho: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="tahoGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#D08E39" />
              <stop offset="100%" stopColor="#C17A2D" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#tahoGradient)" />
          <path
            fill="#FFF"
            d="M20 8c-6.6 0-12 5.4-12 12s5.4 12 12 12 12-5.4 12-12-5.4-12-12-12zm-4 8h8v2h-8v-2zm0 4h8v2h-8v-2zm0 4h8v2h-8v-2z"
          />
        </svg>
      ),
      argent: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <defs>
            <linearGradient id="argentGradient" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stopColor="#FF875B" />
              <stop offset="100%" stopColor="#FF6B45" />
            </linearGradient>
          </defs>
          <circle cx="20" cy="20" r="20" fill="url(#argentGradient)" />
          <path
            fill="#FFF"
            d="M20 8l-8 4v8c0 5 3.5 9.5 8 11 4.5-1.5 8-6 8-11v-8l-8-4zm0 3.5l5.5 2.75v6.75c0 3.5-2.5 7-5.5 8.25-3-1.25-5.5-4.75-5.5-8.25v-6.75L20 11.5z"
          />
        </svg>
      ),
      ledger: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <rect width="40" height="40" fill="#000" />
          <path fill="#FFF" d="M8 8h12v12H8V8zm14 0h10v10H22V8zM8 22h10v10H8V22zm14 0h10v10H22V22z" />
        </svg>
      ),
      anyweb3: (
        <svg viewBox="0 0 40 40" className="w-full h-full">
          <circle cx="20" cy="20" r="20" fill="#627EEA" />
          <path fill="#FFF" fillOpacity="0.6" d="M20 4l-.3.9v20.8l.3.3 9.2-5.4z" />
          <path fill="#FFF" d="M20 4l-9.2 16.6L20 26z" />
          <path fill="#FFF" fillOpacity="0.6" d="M20 28.3l-.2.2v7.1l.2.6 9.2-13z" />
          <path fill="#FFF" d="M20 36.2v-7.9l-9.2-5.4z" />
          <path fill="#FFF" fillOpacity="0.2" d="M20 26l9.2-5.4L20 14.3z" />
          <path fill="#FFF" fillOpacity="0.6" d="M10.8 20.6L20 26V14.3z" />
        </svg>
      ),
    }
    return logos[id]
  }

const detectWallets = (): WalletOption[] => {
    const wallets: WalletOption[] = [
      {
        id: "metamask",
        name: "MetaMask",
        icon: "metamask",
        available: typeof window !== "undefined" && !!window.ethereum?.isMetaMask,
        downloadUrl: "https://metamask.io/download/",
        deepLink: `https://metamask.app.link/dapp/${typeof window !== "undefined" ? window.location.host : ""}`,
      },
      {
        id: "coinbase",
        name: "Base",
        icon: "coinbase",
        available:
          typeof window !== "undefined" && !!(window.ethereum?.isCoinbaseWallet || window.coinbaseWalletExtension),
        downloadUrl: "https://www.coinbase.com/wallet/downloads",
        deepLink: `https://go.cb-w.com/dapp?cb_url=${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "trust",
        name: "Trust Wallet",
        icon: "trust",
        available: typeof window !== "undefined" && !!window.ethereum?.isTrust,
        downloadUrl: "https://trustwallet.com/download",
        deepLink: `https://link.trustwallet.com/open_url?coin_id=60&url=${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "phantom",
        name: "Phantom",
        icon: "phantom",
        available: typeof window !== "undefined" && !!(window.phantom?.ethereum || window.ethereum?.isPhantom),
        downloadUrl: "https://phantom.app/download",
        deepLink: `https://phantom.app/ul/browse/${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "rainbow",
        name: "Rainbow",
        icon: "rainbow",
        available: typeof window !== "undefined" && !!window.ethereum?.isRainbow,
        downloadUrl: "https://rainbow.me/download",
        deepLink: `https://rnbwapp.com/`,
      },
      {
        id: "brave",
        name: "Brave Wallet",
        icon: "brave",
        available: typeof window !== "undefined" && !!window.ethereum?.isBraveWallet,
        downloadUrl: "https://brave.com/wallet/",
        deepLink: "https://brave.com/wallet/",
      },
      {
        id: "rabby",
        name: "Rabby Wallet",
        icon: "rabby",
        available: typeof window !== "undefined" && !!window.ethereum?.isRabby,
        downloadUrl: "https://rabby.io/",
        deepLink: "https://rabby.io/",
      },
      {
        id: "zerion",
        name: "Zerion",
        icon: "zerion",
        available: typeof window !== "undefined" && !!window.ethereum?.isZerion,
        downloadUrl: "https://zerion.io/download",
        deepLink: `https://wallet.zerion.io/`,
      },
      {
        id: "okx",
        name: "OKX Wallet",
        icon: "okx",
        available: typeof window !== "undefined" && !!window.okxwallet,
        downloadUrl: "https://www.okx.com/web3",
        deepLink: `okx://wallet/dapp/url?dappUrl=${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "binance",
        name: "Binance Wallet",
        icon: "binance",
        available: typeof window !== "undefined" && !!window.BinanceChain,
        downloadUrl: "https://www.binance.com/en/web3wallet",
        deepLink: "https://www.binance.com/en/web3wallet",
      },
      {
        id: "cryptocom",
        name: "Crypto.com DeFi",
        icon: "cryptocom",
        available: typeof window !== "undefined" && !!window.ethereum?.isDefiWallet,
        downloadUrl: "https://crypto.com/defi-wallet",
        deepLink: `https://wallet.crypto.com/deeplink?url=${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "imtoken",
        name: "imToken",
        icon: "imtoken",
        available: typeof window !== "undefined" && !!window.ethereum?.isImToken,
        downloadUrl: "https://token.im/download",
        deepLink: `imtokenv2://navigate/DappView?url=${typeof window !== "undefined" ? encodeURIComponent(window.location.href) : ""}`,
      },
      {
        id: "tokenpocket",
        name: "TokenPocket",
        icon: "tokenpocket",
        available: typeof window !== "undefined" && !!window.ethereum?.isTokenPocket,
        downloadUrl: "https://www.tokenpocket.pro/en/download/app",
        deepLink: `tpoutside://open?params=${typeof window !== "undefined" ? encodeURIComponent(JSON.stringify({ url: window.location.href })) : ""}`,
      },
      {
        id: "mathwallet",
        name: "Math Wallet",
        icon: "mathwallet",
        available: typeof window !== "undefined" && !!window.ethereum?.isMathWallet,
        downloadUrl: "https://mathwallet.org/",
        deepLink: "https://mathwallet.org/",
      },
      {
        id: "safepal",
        name: "SafePal",
        icon: "safepal",
        available: typeof window !== "undefined" && !!window.ethereum?.isSafePal,
        downloadUrl: "https://www.safepal.com/download",
        deepLink: "https://www.safepal.com/download",
      },
      {
        id: "bitget",
        name: "Bitget Wallet",
        icon: "bitget",
        available: typeof window !== "undefined" && !!window.bitkeep?.ethereum,
        downloadUrl: "https://web3.bitget.com/",
        deepLink: "https://web3.bitget.com/",
      },
      {
        id: "gateio",
        name: "Gate.io Wallet",
        icon: "gateio",
        available: typeof window !== "undefined" && !!window.ethereum?.isGate,
        downloadUrl: "https://www.gate.io/mobileapp",
        deepLink: "https://www.gate.io/mobileapp",
      },
      {
        id: "exodus",
        name: "Exodus",
        icon: "exodus",
        available: typeof window !== "undefined" && !!window.ethereum?.isExodus,
        downloadUrl: "https://www.exodus.com/download/",
        deepLink: "https://www.exodus.com/download/",
      },
      {
        id: "enkrypt",
        name: "Enkrypt",
        icon: "enkrypt",
        available: typeof window !== "undefined" && !!window.ethereum?.isEnkrypt,
        downloadUrl: "https://www.enkrypt.com/",
        deepLink: "https://www.enkrypt.com/",
      },
      {
        id: "frame",
        name: "Frame",
        icon: "frame",
        available: typeof window !== "undefined" && !!window.ethereum?.isFrame,
        downloadUrl: "https://frame.sh/",
        deepLink: "https://frame.sh/",
      },
      {
        id: "taho",
        name: "Taho",
        icon: "taho",
        available: typeof window !== "undefined" && !!window.ethereum?.isTaho,
        downloadUrl: "https://taho.xyz/",
        deepLink: "https://taho.xyz/",
      },
      {
        id: "argent",
        name: "Argent",
        icon: "argent",
        available: typeof window !== "undefined" && !!window.ethereum?.isArgent,
        downloadUrl: "https://www.argent.xyz/",
        deepLink: `https://argent.link/app/`,
      },
      {
        id: "ledger",
        name: "Ledger Live",
        icon: "ledger",
        available: typeof window !== "undefined" && !!window.ethereum?.isLedgerConnect,
        downloadUrl: "https://www.ledger.com/ledger-live",
        deepLink: "https://www.ledger.com/ledger-live",
      },
      {
        id: "walletconnect",
        name: "WalletConnect",
        icon: "walletconnect",
        available: true,
        downloadUrl: "",
        deepLink: `https://metamask.app.link/dapp/${typeof window !== "undefined" ? window.location.host : ""}`,
      },
      {
        id: "anyweb3",
        name: "Any Web3 Wallet",
        icon: "anyweb3",
        available: typeof window !== "undefined" && !!window.ethereum,
        downloadUrl: "https://ethereum.org/en/wallets/find-wallet/",
        deepLink: "https://ethereum.org/en/wallets/find-wallet/",
      },
    ]

return wallets
  }

const connectToWallet = async (wallet: WalletOption) => {
    console.log("[v0] connectToWallet called for:", wallet.name)
    setIsConnecting(true)
    setError("")
    setConnectingWallet(wallet.name)

try {
      console.log("[v0] Checking wallet type:", wallet.id)
      if (wallet.id === "walletconnect") {
        console.log("[v0] WalletConnect selected")
        if (isMobile() && wallet.deepLink) {
          console.log("[v0] Mobile detected, opening deep link")
          window.location.href = wallet.deepLink
          setTimeout(() => {
            setError(
              "If your wallet app didn't open:\n1. Open your wallet app manually\n2. Use the in-app browser\n3. Visit this page",
            )
            setIsConnecting(false)
            setConnectingWallet("")
          }, 2000)
        } else {
          console.log("[v0] Desktop detected, showing install message")
          setError("On desktop, please install a browser wallet extension or use mobile with your wallet app.")
          setIsConnecting(false)
          setConnectingWallet("")
        }
        return
      }

console.log("[v0] Checking if wallet is available:", wallet.available)
      if (!wallet.available) {
        console.log("[v0] Wallet not available")
        if (isMobile() && wallet.deepLink) {
          console.log("[v0] Opening deep link for installation")
          window.location.href = wallet.deepLink
          setTimeout(() => {
            setError(
              `If ${wallet.name} didn't open, please install it first:\n1. Download ${wallet.name} from your app store\n2. Open the app and use its in-app browser\n3. Visit this page`,
            )
            setIsConnecting(false)
            setConnectingWallet("")
          }, 2000)
        } else {
          console.log("[v0] Opening download page")
          setError(`${wallet.name} is not installed. Click below to install it.`)
          setTimeout(() => {
            window.open(wallet.downloadUrl, "_blank")
          }, 1000)
          setIsConnecting(false)
          setConnectingWallet("")
        }
        return
      }

console.log("[v0] Getting ethereum provider...")
      let ethereum = window.ethereum

if (wallet.id === "phantom" && window.phantom?.ethereum) {
        ethereum = window.phantom.ethereum
      } else if (wallet.id === "okx" && window.okxwallet) {
        ethereum = window.okxwallet
      } else if (wallet.id === "binance" && window.BinanceChain) {
        ethereum = window.BinanceChain
      } else if (wallet.id === "bitget" && window.bitkeep?.ethereum) {
        ethereum = window.bitkeep.ethereum
      } else if (window.ethereum?.providers) {
        // Handle multiple providers
        const providerMap: Record<string, (p: any) => boolean> = {
          metamask: (p) => p.isMetaMask,
          coinbase: (p) => p.isCoinbaseWallet,
          trust: (p) => p.isTrust,
          rainbow: (p) => p.isRainbow,
          brave: (p) => p.isBraveWallet,
          rabby: (p) => p.isRabby,
          zerion: (p) => p.isZerion,
          cryptocom: (p) => p.isDefiWallet,
          imtoken: (p) => p.isImToken,
          tokenpocket: (p) => p.isTokenPocket,
          mathwallet: (p) => p.isMathWallet,
          safepal: (p) => p.isSafePal,
          gateio: (p) => p.isGate,
          exodus: (p) => p.isExodus,
          enkrypt: (p) => p.isEnkrypt,
          frame: (p) => p.isFrame,
          taho: (p) => p.isTaho,
          argent: (p) => p.isArgent,
          ledger: (p) => p.isLedgerConnect,
        }

const checkProvider = providerMap[wallet.id]
        if (checkProvider) {
          const provider = window.ethereum.providers.find(checkProvider)
          if (provider) {
            ethereum = provider
          }
        }
      }

if (!ethereum) {
        console.log("[v0] No ethereum provider found")
        setError(`${wallet.name} wallet not found. Please try again or use a different wallet.`)
        setIsConnecting(false)
        setConnectingWallet("")
        return
      }

console.log("[v0] Requesting accounts from wallet...")
      const accounts = await ethereum.request({
        method: "eth_requestAccounts",
      })
      console.log("[v0] Accounts received:", accounts.length)

if (accounts.length === 0) {
        console.log("[v0] No accounts found")
        setError("No accounts found. Please unlock your wallet.")
        setIsConnecting(false)
        setConnectingWallet("")
        return
      }

const address = accounts[0]
      console.log("[v0] Got address:", address)

console.log("[v0] Checking if address already connected...")
      const addressAlreadyConnected = connectedWallets.some((w) => w.address.toLowerCase() === address.toLowerCase())
      if (addressAlreadyConnected) {
        console.log("[v0] Address already connected")
        setError("This wallet address is already connected. Please use a different account.")
        setIsConnecting(false)
        setConnectingWallet("")
        return
      }

console.log("[v0] Getting balance...")
      const balanceHex = await ethereum.request({
        method: "eth_getBalance",
        params: [address, "latest"],
      })
      console.log("[v0] Balance hex:", balanceHex)

const balanceWei = Number.parseInt(balanceHex, 16)
      const balanceEth = (balanceWei / 1e18).toFixed(4)
      console.log("[v0] Balance ETH:", balanceEth)

console.log("[v0] Calling onConnect with wallet info...")
      const walletInfo = {
        address,
        balance: balanceEth,
        provider: wallet.id,
        name: wallet.name,
      }
      console.log("[v0] Wallet info:", walletInfo)

handleModalClose()

onConnect(walletInfo)
      console.log("[v0] onConnect called successfully")

await new Promise((resolve) => setTimeout(resolve, 100))

if (typeof window !== "undefined") {
        const savedHistory = localStorage.getItem("wallet_history")
        console.log("[v0] Verified history in localStorage after save:", savedHistory)
        if (!savedHistory || savedHistory === "null") {
          console.error("[v0] WARNING: History was not saved to localStorage!")
        }
      }
    } catch (err: any) {
      console.error("[v0] Wallet connection error:", err)
      if (err.code === 4001) {
        setError("Connection rejected. Please approve the connection request in your wallet.")
      } else {
        setError(err.message || "Failed to connect wallet. Please try again.")
      }
      setConnectingWallet("")
    } finally {
      setIsConnecting(false)
      console.log("[v0] connectToWallet finished")
    }
  }

const availableWallets = detectWallets()

const isModalOpen = externalIsOpen !== undefined ? externalIsOpen : showWalletModal
  const handleModalClose = () => {
    if (onClose) {
      onClose()
    } else {
      setShowWalletModal(false)
    }
    setConnectingWallet("")
  }

return (
    <>
      {externalIsOpen === undefined && (
        <Card className="p-8 md:p-12 bg-card border-border w-full">
          <div className="text-center">
            <h3 className="text-3xl md:text-4xl font-bold text-foreground mb-8 md:mb-12">
              {connectedWallets.length > 0 ? "Connect Another Wallet" : "Connect Your Wallet"}
            </h3>

{!hasBuiltInWallet && (
              <>
                <div className="mb-6">
                  <BuiltInWallet onConnect={onConnect} />
                </div>

<div className="relative my-8">
                  <div className="absolute inset-0 flex items-center">
                    <div className="w-full border-t border-border"></div>
                  </div>
                  <div className="relative flex justify-center text-sm">
                    <span className="px-4 bg-card text-muted-foreground">Or connect external wallet</span>
                  </div>
                </div>
              </>
            )}

<Button
              size="lg"
              onClick={() => {
                console.log("[v0] Connect External Wallet button clicked")
                console.log("[v0] showWalletModal before:", showWalletModal)
                setShowWalletModal(true)
                console.log("[v0] showWalletModal set to true")
              }}
              className="w-full bg-black text-white hover:bg-black/90 h-14 text-lg font-semibold"
            >
              <Wallet className="w-5 h-5 mr-2" />
              Connect External Wallet
            </Button>

{error && (
              <div className="mt-6 p-4 rounded-lg bg-destructive/10 border border-destructive/20">
                <p className="text-base text-destructive whitespace-pre-line">{error}</p>
              </div>
            )}
          </div>
        </Card>
      )}

{isModalOpen && (
        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50 p-4">
          {console.log("[v0] ===== WALLET MODAL IS RENDERING =====")}
          <Card className="w-full max-w-md max-h-[80vh] overflow-y-auto p-6 bg-card border-border relative">
            <button
              onClick={() => {
                console.log("[v0] Close button clicked")
                handleModalClose()
              }}
              className="absolute top-4 right-4 text-muted-foreground hover:text-foreground"
              disabled={isConnecting}
            >
              <X className="w-5 h-5" />
            </button>

<h3 className="text-xl font-bold text-foreground mb-2">Choose Wallet</h3>
            <p className="text-sm text-muted-foreground mb-6">
              {connectingWallet
                ? `Approve the connection in your ${connectingWallet} popup`
                : "Select your wallet - you'll approve the connection in the next step"}
            </p>

{connectingWallet && (
              <div className="mb-4 p-4 rounded-lg bg-primary/10 border border-primary/20 flex items-center gap-3">
                <Loader2 className="w-5 h-5 animate-spin text-primary" />
                <div className="flex-1 text-left">
                  <p className="text-sm font-medium text-foreground">Waiting for approval...</p>
                  <p className="text-xs text-muted-foreground">
                    Check your {connectingWallet} for a connection request
                  </p>
                </div>
              </div>
            )}

<div className="space-y-3">
              {console.log("[v0] Rendering wallet options, count:", availableWallets.length)}
              {availableWallets.map((wallet) => (
                <button
                  key={wallet.id}
                  onClick={() => {
                    console.log("[v0] ===== WALLET OPTION CLICKED =====")
                    console.log("[v0] Wallet clicked:", wallet.name, wallet.id)
                    console.log("[v0] Wallet available:", wallet.available)
                    console.log("[v0] Calling connectToWallet...")
                    connectToWallet(wallet)
                  }}
                  disabled={isConnecting}
                  className="w-full p-4 rounded-lg border border-border bg-background hover:bg-accent transition-colors flex items-center gap-4 disabled:opacity-50 disabled:cursor-not-allowed"
                >
                  <div className="w-10 h-10 rounded-full bg-card flex items-center justify-center flex-shrink-0">
                    {getWalletLogo(wallet.id)}
                  </div>
                  <div className="flex-1 text-left">
                    <p className="font-semibold text-foreground">{wallet.name}</p>
                    <p className="text-xs text-muted-foreground">
                      {wallet.available ? "Available" : "Not installed - Tap to install"}
                    </p>
                  </div>
                </button>
              ))}
            </div>

<div className="mt-6 pt-6 border-t border-border">
              <p className="text-xs text-muted-foreground text-center">
                {isMobile()
                  ? "Tap any wallet to connect or install. WalletConnect works with most wallet apps."
                  : "On mobile? Use your wallet app's in-app browser for the best experience"}
              </p>
            </div>
          </Card>
        </div>
      )}
    </>
  )
}

declare global {
  interface Window {
    ethereum?: any
    coinbaseWalletExtension?: any
    phantom?: any
    okxwallet?: any
    BinanceChain?: any
    bitkeep?: any
  }
}
[V0_FILE]sql:file="scripts/003_add_mfa_table.sql" isMerged="true"
-- Multi-Factor Authentication Settings Table
CREATE TABLE IF NOT EXISTS public.mfa_settings (
  id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id uuid REFERENCES auth.users(id) ON DELETE CASCADE UNIQUE NOT NULL,
  totp_secret text,
  enabled boolean DEFAULT false,
  backup_codes text[],
  verified_at timestamp with time zone,
  created_at timestamp with time zone DEFAULT timezone('utc'::text, now()) NOT NULL,
  updated_at timestamp with time zone DEFAULT timezone('utc'::text, now()) NOT NULL
);

-- Add password history tracking to prevent reuse
CREATE TABLE IF NOT EXISTS public.password_history (
  id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id uuid REFERENCES auth.users(id) ON DELETE CASCADE NOT NULL,
  password_hash text NOT NULL,
  created_at timestamp with time zone DEFAULT timezone('utc'::text, now()) NOT NULL
);

-- Enable Row Level Security
ALTER TABLE public.mfa_settings ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.password_history ENABLE ROW LEVEL SECURITY;

-- MFA settings policies (users can only access their own MFA settings)
CREATE POLICY "mfa_settings_select_own" ON public.mfa_settings FOR SELECT USING (auth.uid() = user_id);
CREATE POLICY "mfa_settings_insert_own" ON public.mfa_settings FOR INSERT WITH CHECK (auth.uid() = user_id);
CREATE POLICY "mfa_settings_update_own" ON public.mfa_settings FOR UPDATE USING (auth.uid() = user_id);
CREATE POLICY "mfa_settings_delete_own" ON public.mfa_settings FOR DELETE USING (auth.uid() = user_id);

-- Password history policies
CREATE POLICY "password_history_select_own" ON public.password_history FOR SELECT USING (auth.uid() = user_id);
CREATE POLICY "password_history_insert_own" ON public.password_history FOR INSERT WITH CHECK (auth.uid() = user_id);

-- Create indexes for performance
CREATE INDEX IF NOT EXISTS mfa_settings_user_id_idx ON public.mfa_settings(user_id);
CREATE INDEX IF NOT EXISTS password_history_user_id_idx ON public.password_history(user_id);

-- Trigger to auto-update updated_at on mfa_settings
CREATE TRIGGER set_mfa_updated_at
  BEFORE UPDATE ON public.mfa_settings
  FOR EACH ROW
  EXECUTE FUNCTION public.handle_updated_at();
[V0_FILE]typescriptreact:file="components/mfa-setup.tsx" isMerged="true"
"use client"

import { useState } from "react"
import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"
import { InputOTP, InputOTPGroup, InputOTPSlot } from "@/components/ui/input-otp"
import { generateTOTPSecret, generateQRCodeURL, verifyTOTP, generateBackupCodes, enableMFA } from "@/lib/mfa"
import { Shield, Copy, Check, Download } from "lucide-react"
import QRCode from "qrcode"
import { useEffect } from "react"

interface MFASetupProps {
  open: boolean
  onClose: () => void
  userId: string
  userEmail: string
  onComplete: () => void
}

export function MFASetup({ open, onClose, userId, userEmail, onComplete }: MFASetupProps) {
  const [step, setStep] = useState<"qr" | "verify" | "backup">("qr")
  const [secret, setSecret] = useState("")
  const [qrCodeUrl, setQrCodeUrl] = useState("")
  const [verificationCode, setVerificationCode] = useState("")
  const [backupCodes, setBackupCodes] = useState<string[]>([])
  const [copied, setCopied] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")

useEffect(() => {
    if (open) {
      const newSecret = generateTOTPSecret()
      setSecret(newSecret)

const otpAuthUrl = generateQRCodeURL(newSecret, userEmail)
      QRCode.toDataURL(otpAuthUrl).then(setQrCodeUrl)

setBackupCodes(generateBackupCodes())
    }
  }, [open, userEmail])

const handleVerify = async () => {
    if (!verificationCode || verificationCode.length !== 6) {
      setError("Please enter a 6-digit code")
      return
    }

setLoading(true)
    setError("")

const isValid = verifyTOTP(verificationCode, secret)

if (!isValid) {
      setError("Invalid code. Please try again.")
      setLoading(false)
      return
    }

// Save MFA settings
    const success = await enableMFA(userId, secret, backupCodes)

if (!success) {
      setError("Failed to enable MFA. Please try again.")
      setLoading(false)
      return
    }

setStep("backup")
    setLoading(false)
  }

const handleCopySecret = () => {
    navigator.clipboard.writeText(secret)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

const handleDownloadBackupCodes = () => {
    const content = `LinkFiCrypto Backup Codes\n\nKeep these codes safe! Each can be used once to access your account if you lose your authenticator.\n\n${backupCodes.join("\n")}\n\nGenerated: ${new Date().toLocaleString()}`
    const blob = new Blob([content], { type: "text/plain" })
    const url = URL.createObjectURL(blob)
    const a = document.createElement("a")
    a.href = url
    a.download = "linkficrypto-backup-codes.txt"
    a.click()
  }

const handleComplete = () => {
    onComplete()
    onClose()
  }

return (
    <Dialog open={open} onOpenChange={onClose}>
      <DialogContent className="sm:max-w-md">
        <DialogHeader>
          <DialogTitle className="flex items-center gap-2">
            <Shield className="w-5 h-5 text-primary" />
            Enable Two-Factor Authentication
          </DialogTitle>
          <DialogDescription>Add an extra layer of security to your crypto wallet</DialogDescription>
        </DialogHeader>

{step === "qr" && (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>1. Scan QR Code</Label>
              <p className="text-sm text-muted-foreground">
                Use Google Authenticator, Authy, or any TOTP authenticator app
              </p>
              {qrCodeUrl && (
                <div className="flex justify-center p-4 bg-white rounded-lg">
                  <img src={qrCodeUrl || "/placeholder.svg"} alt="QR Code" className="w-48 h-48" />
                </div>
              )}
            </div>

<div className="space-y-2">
              <Label>Or enter this code manually</Label>
              <div className="flex items-center gap-2">
                <code className="flex-1 p-2 bg-muted rounded text-sm font-mono break-all">{secret}</code>
                <Button type="button" variant="outline" size="sm" onClick={handleCopySecret}>
                  {copied ? <Check className="w-4 h-4" /> : <Copy className="w-4 h-4" />}
                </Button>
              </div>
            </div>

<Button onClick={() => setStep("verify")} className="w-full">
              Next: Verify Code
            </Button>
          </div>
        )}

{step === "verify" && (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>2. Enter Verification Code</Label>
              <p className="text-sm text-muted-foreground">Enter the 6-digit code from your authenticator app</p>
              <div className="flex justify-center">
                <InputOTP maxLength={6} value={verificationCode} onChange={setVerificationCode}>
                  <InputOTPGroup>
                    <InputOTPSlot index={0} />
                    <InputOTPSlot index={1} />
                    <InputOTPSlot index={2} />
                    <InputOTPSlot index={3} />
                    <InputOTPSlot index={4} />
                    <InputOTPSlot index={5} />
                  </InputOTPGroup>
                </InputOTP>
              </div>
            </div>

{error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}

<div className="flex gap-2">
              <Button variant="outline" onClick={() => setStep("qr")} className="flex-1">
                Back
              </Button>
              <Button onClick={handleVerify} disabled={loading || verificationCode.length !== 6} className="flex-1">
                {loading ? "Verifying..." : "Verify & Enable"}
              </Button>
            </div>
          </div>
        )}

{step === "backup" && (
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>3. Save Backup Codes</Label>
              <p className="text-sm text-red-600 dark:text-red-400 font-medium">
                ⚠️ Save these codes! You'll need them if you lose access to your authenticator.
              </p>
              <div className="p-4 bg-muted rounded-lg space-y-1 max-h-64 overflow-y-auto">
                {backupCodes.map((code, i) => (
                  <div key={i} className="font-mono text-sm">
                    {code}
                  </div>
                ))}
              </div>
            </div>

<Button variant="outline" onClick={handleDownloadBackupCodes} className="w-full bg-transparent">
              <Download className="w-4 h-4 mr-2" />
              Download Backup Codes
            </Button>

<Button onClick={handleComplete} className="w-full">
              I've Saved My Backup Codes
            </Button>
          </div>
        )}
      </DialogContent>
    </Dialog>
  )
}
[V0_FILE]typescriptreact:file="components/mfa-verify.tsx" isMerged="true"
"use client"

import { useState } from "react"
import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"
import { InputOTP, InputOTPGroup, InputOTPSlot } from "@/components/ui/input-otp"
import { verifyMFACode } from "@/lib/mfa"
import { Shield } from "lucide-react"

interface MFAVerifyProps {
  open: boolean
  onClose: () => void
  userId: string
  onVerified: () => void
}

export function MFAVerify({ open, onClose, userId, onVerified }: MFAVerifyProps) {
  const [code, setCode] = useState("")
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [useBackupCode, setUseBackupCode] = useState(false)

const handleVerify = async () => {
    if (!code || (code.length !== 6 && !useBackupCode)) {
      setError("Please enter a valid code")
      return
    }

setLoading(true)
    setError("")

const isValid = await verifyMFACode(userId, code)

if (!isValid) {
      setError("Invalid code. Please try again.")
      setLoading(false)
      return
    }

onVerified()
    onClose()
  }

return (
    <Dialog open={open} onOpenChange={onClose}>
      <DialogContent className="sm:max-w-md">
        <DialogHeader>
          <DialogTitle className="flex items-center gap-2">
            <Shield className="w-5 h-5 text-primary" />
            Two-Factor Authentication
          </DialogTitle>
          <DialogDescription>
            {useBackupCode ? "Enter one of your backup codes" : "Enter the code from your authenticator app"}
          </DialogDescription>
        </DialogHeader>

<div className="space-y-4">
          <div className="space-y-2">
            <Label>{useBackupCode ? "Backup Code" : "Verification Code"}</Label>
            {useBackupCode ? (
              <input
                type="text"
                value={code}
                onChange={(e) => setCode(e.target.value.toUpperCase())}
                placeholder="XXXX-XXXX"
                className="w-full px-3 py-2 border rounded-md"
                maxLength={9}
              />
            ) : (
              <div className="flex justify-center">
                <InputOTP maxLength={6} value={code} onChange={setCode}>
                  <InputOTPGroup>
                    <InputOTPSlot index={0} />
                    <InputOTPSlot index={1} />
                    <InputOTPSlot index={2} />
                    <InputOTPSlot index={3} />
                    <InputOTPSlot index={4} />
                    <InputOTPSlot index={5} />
                  </InputOTPGroup>
                </InputOTP>
              </div>
            )}
          </div>

{error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}

<Button onClick={handleVerify} disabled={loading || !code} className="w-full">
            {loading ? "Verifying..." : "Verify"}
          </Button>

<Button variant="link" onClick={() => setUseBackupCode(!useBackupCode)} className="w-full text-sm">
            {useBackupCode ? "Use authenticator app instead" : "Use backup code instead"}
          </Button>
        </div>
      </DialogContent>
    </Dialog>
  )
}
[V0_FILE]typescriptreact:file="components/security-banner.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClient } from "@/lib/supabase/client"
import { Shield, X } from "lucide-react"
import { Button } from "@/components/ui/button"
import { isMFAEnabled } from "@/lib/mfa"
import Link from "next/link"

export function SecurityBanner() {
  const [show, setShow] = useState(false)
  const [dismissed, setDismissed] = useState(false)
  const supabase = createClient()

useEffect(() => {
    checkMFAStatus()
  }, [])

const checkMFAStatus = async () => {
    // Check if banner was previously dismissed
    const dismissedFlag = localStorage.getItem("mfa_banner_dismissed")
    if (dismissedFlag === "true") {
      setDismissed(true)
      return
    }

const {
      data: { user },
    } = await supabase.auth.getUser()
    if (!user) return

const enabled = await isMFAEnabled(user.id)
    setShow(!enabled)
  }

const handleDismiss = () => {
    localStorage.setItem("mfa_banner_dismissed", "true")
    setDismissed(true)
    setShow(false)
  }

if (!show || dismissed) return null

return (
    <div className="bg-gradient-to-r from-orange-500 to-red-500 text-white p-4 relative">
      <div className="max-w-6xl mx-auto flex items-center justify-between gap-4">
        <div className="flex items-center gap-3 flex-1">
          <Shield className="w-6 h-6 flex-shrink-0" />
          <div className="flex-1">
            <p className="font-semibold">Secure Your Crypto Wallet</p>
            <p className="text-sm opacity-90">
              Enable two-factor authentication to add an extra layer of protection to your account
            </p>
          </div>
        </div>
        <div className="flex items-center gap-2">
          <Link href="/settings/security">
            <Button variant="secondary" size="sm" className="bg-white text-orange-600 hover:bg-gray-100">
              Enable 2FA
            </Button>
          </Link>
          <button
            onClick={handleDismiss}
            className="p-1 hover:bg-white/20 rounded transition-colors"
            aria-label="Dismiss"
          >
            <X className="w-5 h-5" />
          </button>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescript:file="lib/mfa.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { encode as base32Encode } from "hi-base32"
import { createClient } from "@/lib/supabase/client"

/**
 * Generate a new TOTP secret for MFA using Web Crypto API
 */
export function generateTOTPSecret(): string {
  const buffer = new Uint8Array(20)
  crypto.getRandomValues(buffer)
  return base32Encode(Array.from(buffer))
}

/**
 * Generate a QR code URL for authenticator apps
 */
export function generateQRCodeURL(secret: string, email: string, issuer = "LinkFiCrypto"): string {
  const params = new URLSearchParams({
    secret,
    issuer,
    algorithm: "SHA1",
    digits: "6",
    period: "30",
  })
  return `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(email)}?${params.toString()}`
}

/**
 * Generate TOTP code using HMAC-SHA1
 */
async function generateTOTP(secret: string, timeStep = 30): Promise<string> {
  const epoch = Math.floor(Date.now() / 1000)
  const counter = Math.floor(epoch / timeStep)

// Decode base32 secret
  const key = base32Decode(secret)

// Convert counter to 8-byte buffer
  const counterBuffer = new ArrayBuffer(8)
  const counterView = new DataView(counterBuffer)
  counterView.setBigUint64(0, BigInt(counter), false)

// Import key for HMAC
  const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-1" }, false, ["sign"])

// Generate HMAC
  const signature = await crypto.subtle.sign("HMAC", cryptoKey, counterBuffer)
  const signatureArray = new Uint8Array(signature)

// Dynamic truncation
  const offset = signatureArray[signatureArray.length - 1] & 0x0f
  const binary =
    ((signatureArray[offset] & 0x7f) << 24) |
    ((signatureArray[offset + 1] & 0xff) << 16) |
    ((signatureArray[offset + 2] & 0xff) << 8) |
    (signatureArray[offset + 3] & 0xff)

const otp = binary % 1000000
  return otp.toString().padStart(6, "0")
}

/**
 * Decode base32 string to Uint8Array
 */
function base32Decode(encoded: string): Uint8Array {
  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
  const cleanInput = encoded.toUpperCase().replace(/=+$/, "")
  const bits: number[] = []

for (const char of cleanInput) {
    const val = alphabet.indexOf(char)
    if (val === -1) continue
    for (let i = 4; i >= 0; i--) {
      bits.push((val >> i) & 1)
    }
  }

const bytes: number[] = []
  for (let i = 0; i + 8 <= bits.length; i += 8) {
    let byte = 0
    for (let j = 0; j < 8; j++) {
      byte = (byte << 1) | bits[i + j]
    }
    bytes.push(byte)
  }

return new Uint8Array(bytes)
}

/**
 * Verify a TOTP code
 */
export async function verifyTOTP(token: string, secret: string): Promise<boolean> {
  try {
    // Check current time window and ±1 window for clock drift
    for (let drift = -1; drift <= 1; drift++) {
      const timeStep = 30
      const epoch = Math.floor(Date.now() / 1000)
      const counter = Math.floor(epoch / timeStep) + drift

const key = base32Decode(secret)
      const counterBuffer = new ArrayBuffer(8)
      const counterView = new DataView(counterBuffer)
      counterView.setBigUint64(0, BigInt(counter), false)

const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-1" }, false, ["sign"])

const signature = await crypto.subtle.sign("HMAC", cryptoKey, counterBuffer)
      const signatureArray = new Uint8Array(signature)

const offset = signatureArray[signatureArray.length - 1] & 0x0f
      const binary =
        ((signatureArray[offset] & 0x7f) << 24) |
        ((signatureArray[offset + 1] & 0xff) << 16) |
        ((signatureArray[offset + 2] & 0xff) << 8) |
        (signatureArray[offset + 3] & 0xff)

const otp = (binary % 1000000).toString().padStart(6, "0")

if (otp === token) {
        return true
      }
    }

return false
  } catch (error) {
    console.error("TOTP verification error:", error)
    return false
  }
}

/**
 * Generate backup codes for account recovery
 */
export function generateBackupCodes(count = 8): string[] {
  const codes: string[] = []
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

for (let i = 0; i < count; i++) {
    let code = ""
    for (let j = 0; j < 8; j++) {
      code += characters.charAt(Math.floor(Math.random() * characters.length))
    }
    // Format as XXXX-XXXX
    codes.push(`${code.slice(0, 4)}-${code.slice(4, 8)}`)
  }

return codes
}

/**
 * Check if user has MFA enabled
 */
export async function isMFAEnabled(userId: string): Promise<boolean> {
  const supabase = createClient()

const { data } = await supabase.from("mfa_settings").select("enabled").eq("user_id", userId).single()

return data?.enabled || false
}

/**
 * Enable MFA for user
 */
export async function enableMFA(userId: string, secret: string, backupCodes: string[]): Promise<boolean> {
  const supabase = createClient()

const { error } = await supabase.from("mfa_settings").upsert({
    user_id: userId,
    totp_secret: secret,
    enabled: true,
    backup_codes: backupCodes,
    verified_at: new Date().toISOString(),
  })

return !error
}

/**
 * Disable MFA for user
 */
export async function disableMFA(userId: string): Promise<boolean> {
  const supabase = createClient()

const { error } = await supabase.from("mfa_settings").update({ enabled: false }).eq("user_id", userId)

return !error
}

/**
 * Get MFA settings for user
 */
export async function getMFASettings(userId: string) {
  const supabase = createClient()

const { data, error } = await supabase.from("mfa_settings").select("*").eq("user_id", userId).single()

if (error) return null
  return data
}

/**
 * Verify MFA code (TOTP or backup code)
 */
export async function verifyMFACode(userId: string, code: string): Promise<boolean> {
  const settings = await getMFASettings(userId)

if (!settings || !settings.enabled) return false

// Try TOTP verification
  if (settings.totp_secret && (await verifyTOTP(code.replace(/\s/g, ""), settings.totp_secret))) {
    return true
  }

// Try backup code verification
  if (settings.backup_codes && settings.backup_codes.includes(code.toUpperCase())) {
    // Remove used backup code
    const supabase = createClient()
    const newBackupCodes = settings.backup_codes.filter((c: string) => c !== code.toUpperCase())

await supabase.from("mfa_settings").update({ backup_codes: newBackupCodes }).eq("user_id", userId)

return true
  }

return false
}
[V0_FILE]typescript:file="lib/password-security.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { createClient } from "@/lib/supabase/client"
import * as crypto from "crypto"

export interface PasswordStrengthResult {
  score: number
  label: string
  color: string
  feedback: string[]
  isSecure: boolean
}

export interface PasswordValidation {
  isValid: boolean
  score: number
  checks: Array<{
    valid: boolean
    message: string
  }>
}

/**
 * Calculate entropy of password
 */
function calculateEntropy(password: string): number {
  const charSetSizes = {
    lowercase: /[a-z]/.test(password) ? 26 : 0,
    uppercase: /[A-Z]/.test(password) ? 26 : 0,
    digits: /\d/.test(password) ? 10 : 0,
    special: /[!@#$%^&*(),.?":{}|<>]/.test(password) ? 32 : 0,
  }

const charSetSize = Object.values(charSetSizes).reduce((a, b) => a + b, 0)
  return Math.log2(Math.pow(charSetSize, password.length))
}

/**
 * Check if password contains common patterns
 */
function hasCommonPatterns(password: string): boolean {
  const commonPatterns = [
    /^(password|12345|qwerty|abc123|letmein|welcome|monkey|dragon)/i,
    /(.)\1{2,}/, // Repeating characters
    /(012|123|234|345|456|567|678|789|890)/, // Sequential numbers
    /(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz)/i, // Sequential letters
  ]

return commonPatterns.some((pattern) => pattern.test(password))
}

/**
 * Enhanced password strength validation
 */
export function validatePasswordStrength(password: string): PasswordStrengthResult {
  if (!password) {
    return {
      score: 0,
      label: "No password",
      color: "text-gray-500",
      feedback: ["Please enter a password"],
      isSecure: false,
    }
  }

let score = 0
  const feedback: string[] = []

// Minimum length (14+ chars for crypto wallet security)
  if (password.length >= 14) {
    score += 2
  } else if (password.length >= 12) {
    score += 1
    feedback.push("Consider using 14+ characters for crypto security")
  } else if (password.length >= 8) {
    feedback.push("Password too short - use at least 12 characters")
  } else {
    feedback.push("Password must be at least 8 characters")
    return {
      score: 0,
      label: "Too weak",
      color: "text-red-500",
      feedback,
      isSecure: false,
    }
  }

// Character diversity
  const hasLower = /[a-z]/.test(password)
  const hasUpper = /[A-Z]/.test(password)
  const hasDigit = /\d/.test(password)
  const hasSpecial = /[!@#$%^&*(),.?":{}|<>]/.test(password)

if (hasLower && hasUpper) score++
  else feedback.push("Include both uppercase and lowercase letters")

if (hasDigit) score++
  else feedback.push("Include at least one number")

if (hasSpecial) score++
  else feedback.push("Include at least one special character (!@#$%^&*)")

// Check entropy
  const entropy = calculateEntropy(password)
  if (entropy >= 60) score++
  else if (entropy < 40) feedback.push("Password is too predictable")

// Penalize common patterns
  if (hasCommonPatterns(password)) {
    score = Math.max(0, score - 2)
    feedback.push("Avoid common words and patterns")
  }

// Determine rating
  let label = "Weak"
  let color = "text-red-500"
  let isSecure = false

if (score <= 2) {
    label = "Weak"
    color = "text-red-500"
  } else if (score <= 4) {
    label = "Fair"
    color = "text-orange-500"
  } else if (score <= 6) {
    label = "Good"
    color = "text-yellow-500"
    isSecure = true
  } else {
    label = "Strong"
    color = "text-green-500"
    isSecure = true
  }

return {
    score,
    label,
    color,
    feedback: feedback.slice(0, 3),
    isSecure,
  }
}

/**
 * Validate password with detailed checks
 */
export function validatePassword(password: string): PasswordValidation {
  const checks = [
    {
      valid: password.length >= 12,
      message: "At least 12 characters long",
    },
    {
      valid: /[a-z]/.test(password) && /[A-Z]/.test(password),
      message: "Contains uppercase and lowercase letters",
    },
    {
      valid: /\d/.test(password),
      message: "Contains at least one number",
    },
    {
      valid: /[!@#$%^&*(),.?":{}|<>]/.test(password),
      message: "Contains at least one special character",
    },
    {
      valid: !hasCommonPatterns(password),
      message: "Does not contain common patterns",
    },
  ]

const validChecks = checks.filter((c) => c.valid).length
  const score = Math.min(5, Math.floor((validChecks / checks.length) * 5))

return {
    isValid: checks.every((c) => c.valid),
    score,
    checks,
  }
}

/**
 * Hash password for history tracking (client-side)
 */
export function hashPassword(password: string): string {
  return crypto.createHash("sha256").update(password).digest("hex")
}

/**
 * Check if password was used recently
 */
export async function isPasswordReused(userId: string, password: string): Promise<boolean> {
  const supabase = createClient()
  const passwordHash = hashPassword(password)

const { data } = await supabase
    .from("password_history")
    .select("password_hash")
    .eq("user_id", userId)
    .order("created_at", { ascending: false })
    .limit(5) // Check last 5 passwords

return data?.some((record) => record.password_hash === passwordHash) || false
}

/**
 * Add password to history
 */
export async function addPasswordToHistory(userId: string, password: string): Promise<void> {
  const supabase = createClient()
  const passwordHash = hashPassword(password)

await supabase.from("password_history").insert({
    user_id: userId,
    password_hash: passwordHash,
  })
}
[V0_FILE]json:file="package.json" isEdit="true" isMerged="true"
{
  "name": "my-v0-project",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "eslint ."
  },
  "dependencies": {
    "@hookform/resolvers": "^3.10.0",
    "@radix-ui/react-accordion": "1.2.2",
    "@radix-ui/react-alert-dialog": "1.1.4",
    "@radix-ui/react-aspect-ratio": "1.1.1",
    "@radix-ui/react-avatar": "1.1.2",
    "@radix-ui/react-checkbox": "1.1.3",
    "@radix-ui/react-collapsible": "1.1.2",
    "@radix-ui/react-context-menu": "2.2.4",
    "@radix-ui/react-dialog": "1.1.4",
    "@radix-ui/react-dropdown-menu": "2.1.4",
    "@radix-ui/react-hover-card": "1.1.4",
    "@radix-ui/react-label": "2.1.1",
    "@radix-ui/react-menubar": "1.1.4",
    "@radix-ui/react-navigation-menu": "1.2.3",
    "@radix-ui/react-popover": "1.1.4",
    "@radix-ui/react-progress": "1.1.1",
    "@radix-ui/react-radio-group": "1.2.2",
    "@radix-ui/react-scroll-area": "1.2.2",
    "@radix-ui/react-select": "2.1.4",
    "@radix-ui/react-separator": "1.1.1",
    "@radix-ui/react-slider": "1.2.2",
    "@radix-ui/react-slot": "1.1.1",
    "@radix-ui/react-switch": "1.1.2",
    "@radix-ui/react-tabs": "1.1.2",
    "@radix-ui/react-toast": "1.2.4",
    "@radix-ui/react-toggle": "1.1.1",
    "@radix-ui/react-toggle-group": "1.1.1",
    "@radix-ui/react-tooltip": "1.1.6",
    "@vercel/analytics": "1.3.1",
    "autoprefixer": "^10.4.20",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "1.0.4",
    "date-fns": "4.1.0",
    "embla-carousel-react": "8.5.1",
    "input-otp": "1.4.1",
    "lucide-react": "^0.454.0",
    "next": "16.0.10",
    "next-themes": "^0.4.6",
    "react": "19.2.0",
    "react-day-picker": "9.8.0",
    "react-dom": "19.2.0",
    "react-hook-form": "^7.60.0",
    "react-resizable-panels": "^2.1.7",
    "recharts": "2.15.4",
    "sonner": "^1.7.4",
    "tailwind-merge": "^3.3.1",
    "tailwindcss-animate": "^1.0.7",
    "vaul": "^0.9.9",
    "zod": "3.25.76",
    "@supabase/ssr": "0.7.0",
    "qrcode.react": "4.2.0",
    "qrcode": "1.5.4",
    "@types/qrcode": "1.5.5",
    "ethers": "6.15.0",
    "hi-base32": "0.5.1",
    "crypto": "1.0.1",
    "crypto-js": "4.2.0",
    "@supabase/supabase-js": "2.90.1"
  },
  "devDependencies": {
    "@tailwindcss/postcss": "^4.1.9",
    "@types/node": "^22",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "postcss": "^8.5",
    "tailwindcss": "^4.1.9",
    "tw-animate-css": "1.3.3",
    "typescript": "^5"
  }
}
[V0_FILE]markdown:file="UNIFIED_WALLET_SYSTEM.md" isMerged="true"
# Unified Wallet & Payments System

## Overview
LinkFiCrypto now has a fully unified account system where the built-in wallet and Payments & Transfers work as ONE integrated account.

## How It Works

### 1. Account Creation (Sign Up)
When a user creates an account at `/auth/sign-up`:
- **Automatic wallet generation**: A secure built-in crypto wallet is automatically created
- **Encrypted storage**: Wallet is encrypted with user's password and stored in:
  - Supabase `profiles` table (cloud backup)
  - Browser localStorage (local access)
- **Single account**: User gets ONE account with wallet capabilities built-in

### 2. Authentication Flow
\`\`\`
User Signs Up → Built-in Wallet Created → Stored in Profile → Auto-Login
                                                                    ↓
                                                    Wallet Dashboard + Payments Active
\`\`\`

### 3. Unified Dashboard
The `WalletDashboard` component integrates everything:
- **Portfolio Value**: Shows real-time USD value using CoinGecko API
- **Payment Features**: Send, Request, Pay At Store tabs built-in
- **Token Management**: Buy Crypto, Swap, Tokens all in one place
- **Balance Syncing**: ETH balance fetched via public RPC (works for all wallet types)

### 4. Real-Time USD Conversion
Located in `lib/token-prices.ts`:
\`\`\`typescript
// Fetches ETH balance via public RPC
eth_getBalance → Convert Wei to ETH

// Fetches current market price
CoinGecko API → Get ETH/USD price

// Calculate USD value
Balance (ETH) × Price (USD) = Portfolio Value
\`\`\`

Updates every 30 seconds automatically.

### 5. Payment Features Integration
All payment features work with the same wallet:
- **PaymentSend**: Send crypto using @username or wallet address
- **PaymentRequest**: Generate QR codes for receiving payments  
- **PaymentLinkGenerator**: Create payment links for stores
- **BuyCrypto**: Add funds to wallet
- **Swap**: Exchange tokens
- **TokenManager**: View and manage all tokens

## Key Files

### Core Components
- `app/auth/sign-up/page.tsx` - Creates wallet during signup
- `components/wallet-dashboard.tsx` - Main unified dashboard
- `components/payments-dashboard.tsx` - Payment features (integrated)
- `lib/wallet-sync.ts` - Cloud sync for built-in wallet
- `lib/token-prices.ts` - Real-time price fetching

### Database
- `profiles` table stores:
  - `encrypted_wallet` - Encrypted wallet data
  - `builtin_wallet_address` - Wallet address
  - `has_builtin_wallet` - Boolean flag
  - `username` - Payment username (@user)

## Features

### For Built-in Wallet Users
✓ Auto-created during signup
✓ Cloud backup in Supabase
✓ Encrypted with user password
✓ Works with all payment features
✓ Real-time USD balance
✓ Multi-factor authentication (optional)

### For External Wallet Users  
✓ Connect MetaMask, Base, etc.
✓ Switch between multiple wallets
✓ Same payment features
✓ Real-time balance updates

## Security Features
- **Password encryption**: Built-in wallets encrypted with user password
- **MFA support**: Optional TOTP-based 2FA
- **Strong passwords**: Enforced password requirements
- **Password reset**: Forgot password flow
- **RLS policies**: Row-level security on all tables

## User Experience
1. **Sign Up** → Wallet automatically created
2. **Log In** → Wallet auto-unlocked and connected
3. **Dashboard** → See portfolio value in USD + ETH
4. **Payments** → Send/receive with username or address
5. **Trading** → Buy crypto, swap tokens, manage portfolio

## Technical Implementation

### Balance Fetching
\`\`\`javascript
// Public RPC call - works for any Ethereum address
fetch('https://eth.llamarpc.com', {
  method: 'POST',
  body: JSON.stringify({
    method: 'eth_getBalance',
    params: [address, 'latest']
  })
})
\`\`\`

### Price Fetching
\`\`\`javascript
// CoinGecko public API - no API key needed
fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd')
\`\`\`

### Authentication Check
\`\`\`javascript
// Check multiple sources
const user = await supabase.auth.getUser() // Supabase auth
const hasBuiltIn = hasWallet() // Local storage check
const isAuthenticated = user || hasBuiltIn // Either works
\`\`\`

## Benefits
1. **One Account**: No separate wallet and payment accounts
2. **Automatic Setup**: Wallet created during signup
3. **Real Prices**: Live market data for accurate values
4. **Seamless UX**: Everything works together
5. **Secure**: Encrypted storage, optional MFA
6. **Flexible**: Works with built-in or external wallets

## Future Enhancements
- Multi-chain support (Polygon, BSC, etc.)
- More tokens beyond ETH
- Transaction history with USD values
- Price alerts and notifications
- Advanced trading features
[V0_FILE]typescriptreact:file="app/auth/login/page.tsx" isMerged="true"
"use client"

import type React from "react"
import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Label } from "@/components/ui/label"
import { createClient } from "@/lib/supabase/client"
import { useRouter, useSearchParams } from "next/navigation"
import Link from "next/link"
import { Eye, EyeOff } from "lucide-react"
import { isMFAEnabled } from "@/lib/mfa"
import { MFAVerify } from "@/components/mfa-verify"
import { decryptWallet } from "@/lib/wallet-generator"

export default function LoginPage() {
  const [email, setEmail] = useState("")
  const [password, setPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [showMFAVerify, setShowMFAVerify] = useState(false)
  const [pendingUserId, setPendingUserId] = useState<string | null>(null)
  const router = useRouter()
  const searchParams = useSearchParams()

const supabase = createClient()

useEffect(() => {
    const urlError = searchParams.get("error")
    if (urlError === "confirmation_failed") {
      setError("Email confirmation failed. Please try again or sign up again.")
    }
  }, [searchParams])

const handleLogin = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)
    setError("")

const { data, error: loginError } = await supabase.auth.signInWithPassword({
      email,
      password,
    })

if (loginError) {
      setError(loginError.message)
      setLoading(false)
    } else if (data.user) {
      const mfaEnabled = await isMFAEnabled(data.user.id)

if (mfaEnabled) {
        setPendingUserId(data.user.id)
        setShowMFAVerify(true)
        setLoading(false)
        return
      }

// Continue with normal login flow
      try {
        const { data: profile } = await supabase
          .from("profiles")
          .select("encrypted_wallet, builtin_wallet_address, has_builtin_wallet")
          .eq("id", data.user.id)
          .single()

// Automatically decrypt wallet using login password
          try {
            const decryptedWallet = await decryptWallet(profile.encrypted_wallet, password)
            // Store decrypted wallet temporarily in session
            sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
            sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(decryptedWallet))
            console.log("[v0] Wallet auto-unlocked successfully")
          } catch (decryptError) {
            console.log("[v0] Failed to auto-unlock wallet, user will need to unlock manually")
          }
        }
      } catch (err) {
        console.log("[v0] No wallet to sync or sync failed:", err)
      }

router.push("/")
      router.refresh()
    }
  }

const handleMFAVerified = async () => {
    if (!pendingUserId) return

const { data } = await supabase.auth.getUser()
    if (!data.user) return

try {
      const { data: profile } = await supabase
        .from("profiles")
        .select("encrypted_wallet, builtin_wallet_address, has_builtin_wallet")
        .eq("id", data.user.id)
        .single()

// Automatically decrypt wallet using login password
        try {
          const decryptedWallet = await decryptWallet(profile.encrypted_wallet, password)
          sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
          sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(decryptedWallet))
          console.log("[v0] Wallet auto-unlocked after MFA")
        } catch (decryptError) {
          console.log("[v0] Failed to auto-unlock wallet after MFA")
        }
      }
    } catch (err) {
      console.log("[v0] No wallet to sync")
    }

router.push("/")
    router.refresh()
  }

return (
    <div className="min-h-screen flex items-center justify-center bg-black p-4">
      <Card className="w-full max-w-md">
        <CardHeader>
          <CardTitle>Welcome Back</CardTitle>
          <CardDescription>Sign in to your LinkFiCrypto account</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleLogin} className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="email">Email</Label>
              <Input
                id="email"
                type="email"
                placeholder="you@example.com"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
                required
              />
            </div>
            <div className="space-y-2">
              <div className="flex items-center justify-between">
                <Label htmlFor="password">Password</Label>
                <Link
                  href="/auth/forgot-password"
                  className="text-xs text-muted-foreground hover:text-primary transition-colors"
                >
                  Forgot password?
                </Link>
              </div>
              <div className="relative">
                <Input
                  id="password"
                  type={showPassword ? "text" : "password"}
                  value={password}
                  onChange={(e) => setPassword(e.target.value)}
                  required
                />
                <button
                  type="button"
                  onClick={() => setShowPassword(!showPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                </button>
              </div>
            </div>
            {error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}
            <Button type="submit" className="w-full" disabled={loading}>
              {loading ? "Signing in..." : "Sign In"}
            </Button>
          </form>
          <div className="mt-4 text-center text-sm">
            Don't have an account?{" "}
            <Link href="/auth/sign-up" className="text-primary hover:underline">
              Sign up
            </Link>
          </div>
        </CardContent>
      </Card>
      {pendingUserId && (
        <MFAVerify
          open={showMFAVerify}
          onClose={() => setShowMFAVerify(false)}
          userId={pendingUserId}
          onVerified={handleMFAVerified}
        />
      )}
    </div>
  )
}
[V0_FILE]typescript:file="app/manifest.ts" isEdit="true" isMerged="true"
import type { MetadataRoute } from "next"

export default function manifest(): MetadataRoute.Manifest {
  return {
    name: "LinkFiCrypto",
    short_name: "LinkFiCrypto",
    description: "Non-Custodial Crypto Wallet - Connect, Send, Receive, and Swap",
    start_url: "/",
    display: "standalone",
    background_color: "#000000",
    theme_color: "#000000",
    icons: [
      {
        src: "/icon-192.png",
        sizes: "192x192",
        type: "image/png",
      },
      {
        src: "/icon-512.png",
        sizes: "512x512",
        type: "image/png",
      },
    ],
  }
}
[V0_FILE]xml:file="public/favicon.svg" isEdit="true" isQuickEdit="true" isMerged="true"
<svg width="180" height="180" viewBox="0 0 1024 1024" fill="none" xmlns="http://www.w3.org/2000/svg">
  <rect width="1024" height="1024" fill="#000000"/>
  <path d="M116 92L480 587V92H918V1011C918 1027.57 894.569 1035.16 886 1020.28L116 92Z" fill="#FFFFFF"/>
</svg>
[V0_FILE]xml:file="public/icon.svg" isEdit="true" isQuickEdit="true" isMerged="true"
<svg width="180" height="180" viewBox="0 0 1024 1024" fill="none" xmlns="http://www.w3.org/2000/svg">
  <style>
    @media (prefers-color-scheme: light) {
      .background { fill: black; }
      .foreground { fill: white; }
    }
    @media (prefers-color-scheme: dark) {
      .background { fill: white; }
      .foreground { fill: black; }
    }
  </style>
  <rect width="1024" height="1024" fill="#000000"/>
  <path d="M116 92L480 587V92H918V1011C918 1027.57 894.569 1035.16 886 1020.28L116 92Z" fill="#FFFFFF"/>
</svg>
[V0_FILE]png:file="public/apple-touch-icon.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/AB943052-BDBA-4E27-B0B1-61C52A493034-CFU47lxGyMDqYvTIu4cpZJ9wuLi530.png" isMerged="true"
[V0_FILE]png:file="public/icon-192.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/AB943052-BDBA-4E27-B0B1-61C52A493034-CFU47lxGyMDqYvTIu4cpZJ9wuLi530.png" isMerged="true"
[V0_FILE]png:file="public/icon-512.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/AB943052-BDBA-4E27-B0B1-61C52A493034-CFU47lxGyMDqYvTIu4cpZJ9wuLi530.png" isMerged="true"
[V0_FILE]xml:file="public/browserconfig.xml" isMerged="true"
<?xml version="1.0" encoding="utf-8"?>
<browserconfig>
  <msapplication>
    <tile>
      <square70x70logo src="/favicon.ico"/>
      <square150x150logo src="/favicon.ico"/>
      <square310x310logo src="/favicon.ico"/>
      <TileColor>#000000</TileColor>
    </tile>
  </msapplication>
</browserconfig>
[V0_FILE]json:file="public/site.webmanifest" isMerged="true"
{
  "name": "LinkFiCrypto",
  "short_name": "LinkFiCrypto",
  "description": "Non-Custodial Crypto Wallet - Connect, Send, Receive, and Swap",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#000000",
  "theme_color": "#000000",
  "icons": [
    {
      "src": "/favicon.ico",
      "sizes": "any",
      "type": "image/x-icon"
    },
    {
      "src": "/favicon.ico",
      "sizes": "192x192",
      "type": "image/x-icon",
      "purpose": "any maskable"
    },
    {
      "src": "/favicon.ico",
      "sizes": "512x512",
      "type": "image/x-icon",
      "purpose": "any maskable"
    }
  ]
}
[V0_FILE]plaintext:file="public/favicon.ico" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/linkficrypto_favicon.ico-MSlf09ebzeDFWRBXSJpGolKtNRdWuo.x-icon" isMerged="true"
[V0_FILE]typescript:file="lib/transaction-storage.ts" isMerged="true"
export interface StoredTransaction {
  hash: string
  from: string
  to: string
  value: string
  timestamp: number
  status: "success" | "pending" | "failed"
  type: "send" | "receive"
  note?: string
}

const STORAGE_KEY = "linkficrypto_transactions"

export function saveTransaction(tx: StoredTransaction) {
  try {
    const stored = localStorage.getItem(STORAGE_KEY)
    const transactions: StoredTransaction[] = stored ? JSON.parse(stored) : []

// Add new transaction at the beginning
    transactions.unshift(tx)

// Keep only last 100 transactions
    if (transactions.length > 100) {
      transactions.splice(100)
    }

localStorage.setItem(STORAGE_KEY, JSON.stringify(transactions))
    console.log("[v0] Transaction saved to local storage:", tx.hash)
  } catch (error) {
    console.error("[v0] Error saving transaction:", error)
  }
}

export function getTransactions(walletAddress: string): StoredTransaction[] {
  try {
    const stored = localStorage.getItem(STORAGE_KEY)
    if (!stored) return []

const allTransactions: StoredTransaction[] = JSON.parse(stored)

// Filter transactions for this wallet address
    return allTransactions.filter(
      (tx) =>
        tx.from.toLowerCase() === walletAddress.toLowerCase() || tx.to.toLowerCase() === walletAddress.toLowerCase(),
    )
  } catch (error) {
    console.error("[v0] Error loading transactions:", error)
    return []
  }
}

export function clearTransactions() {
  try {
    localStorage.removeItem(STORAGE_KEY)
    console.log("[v0] Transactions cleared")
  } catch (error) {
    console.error("[v0] Error clearing transactions:", error)
  }
}
[V0_FILE]typescript:file="lib/transaction-monitor.ts" isMerged="true"
import { ethers } from "ethers"
import { saveTransaction, type StoredTransaction } from "./transaction-storage"

let lastKnownBalance: { [address: string]: string } = {}
let isMonitoring = false

export async function monitorIncomingTransactions(walletAddress: string, provider: ethers.BrowserProvider) {
  if (isMonitoring) return
  isMonitoring = true

try {
    console.log("[v0] Starting transaction monitor for:", walletAddress)

// Get current balance
    const currentBalance = await provider.getBalance(walletAddress)
    const currentBalanceStr = currentBalance.toString()

// Initialize if first time
    if (!lastKnownBalance[walletAddress]) {
      lastKnownBalance[walletAddress] = currentBalanceStr
      console.log("[v0] Initial balance set:", ethers.formatEther(currentBalance), "ETH")
      isMonitoring = false
      return
    }

// Check if balance increased (incoming transaction)
    const lastBalance = BigInt(lastKnownBalance[walletAddress])
    const balanceChange = currentBalance - lastBalance

if (balanceChange > 0n) {
      console.log("[v0] Balance increased! Looking for incoming transaction...")
      console.log("[v0] Previous:", ethers.formatEther(lastBalance), "ETH")
      console.log("[v0] Current:", ethers.formatEther(currentBalance), "ETH")
      console.log("[v0] Increase:", ethers.formatEther(balanceChange), "ETH")

// Search recent blocks for incoming transactions
      await findIncomingTransaction(walletAddress, provider, balanceChange)
    }

// Update last known balance
    lastKnownBalance[walletAddress] = currentBalanceStr
  } catch (error) {
    console.error("[v0] Error monitoring transactions:", error)
  } finally {
    isMonitoring = false
  }
}

async function findIncomingTransaction(
  walletAddress: string,
  provider: ethers.BrowserProvider,
  expectedAmount: bigint,
) {
  try {
    const currentBlock = await provider.getBlockNumber()
    console.log("[v0] Searching last 20 blocks from block:", currentBlock)

// Check last 20 blocks
    for (let i = 0; i < 20; i++) {
      const blockNumber = currentBlock - i
      const block = await provider.getBlock(blockNumber, true)

if (!block || !block.transactions) continue

// Check each transaction in the block
      for (const txHash of block.transactions) {
        try {
          const tx =
            typeof txHash === "string" ? await provider.getTransaction(txHash) : (txHash as ethers.TransactionResponse)

if (!tx) continue

// Check if this transaction is to our wallet
          if (tx.to?.toLowerCase() === walletAddress.toLowerCase()) {
            // Check if the amount matches (within a small margin for gas differences)
            const valueDiff = tx.value > expectedAmount ? tx.value - expectedAmount : expectedAmount - tx.value

// If values are close (within 1% or match exactly), this is likely our transaction
            if (valueDiff === 0n || (valueDiff * 100n) / expectedAmount < 1n) {
              console.log("[v0] Found matching incoming transaction:", tx.hash)

// Save the incoming transaction
              const incomingTx: StoredTransaction = {
                hash: tx.hash,
                from: tx.from,
                to: walletAddress,
                value: tx.value.toString(),
                timestamp: Date.now(),
                status: "success",
                type: "receive",
              }

saveTransaction(incomingTx)
              console.log("[v0] Incoming transaction saved!")
              return
            }
          }
        } catch (txError) {
          console.error("[v0] Error checking transaction:", txError)
        }
      }
    }

console.log("[v0] Could not find matching transaction in recent blocks")
  } catch (error) {
    console.error("[v0] Error finding incoming transaction:", error)
  }
}

export function resetBalanceTracking() {
  lastKnownBalance = {}
  console.log("[v0] Balance tracking reset")
}
[V0_FILE]typescript:file="app/api/transactions/scan/route.ts" isMerged="true"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"
import { NextResponse } from "next/server"

export async function POST(request: Request) {
  try {
    const { walletAddress } = await request.json()

if (!walletAddress) {
      console.log("[v0 API] No wallet address provided")
      return NextResponse.json({ error: "Wallet address required" }, { status: 400 })
    }

console.log("[v0 API] Starting scan for wallet:", walletAddress)

const controller = new AbortController()
    const timeoutId = setTimeout(() => controller.abort(), 15000) // 15 second timeout

try {
      const etherscanUrl = `https://api.etherscan.io/v2/api?chainid=1&module=account&action=txlist&address=${walletAddress}&startblock=0&endblock=99999999&page=1&offset=100&sort=desc&apikey=YourApiKeyToken`
      console.log("[v0 API] Fetching from Etherscan Mainnet v2 API...")

const etherscanResponse = await fetch(etherscanUrl, {
        signal: controller.signal,
        headers: {
          Accept: "application/json",
        },
      })

clearTimeout(timeoutId)

console.log("[v0 API] Etherscan response status:", etherscanResponse.status)

if (!etherscanResponse.ok) {
        throw new Error(`Etherscan API returned status ${etherscanResponse.status}`)
      }

const etherscanData = await etherscanResponse.json()
      console.log("[v0 API] Etherscan data:", {
        status: etherscanData.status,
        message: etherscanData.message,
        resultCount: etherscanData.result?.length || 0,
      })

if (etherscanData.status !== "1") {
        console.log("[v0 API] Etherscan returned non-success status")
        return NextResponse.json({
          success: true,
          savedCount: 0,
          totalFound: 0,
          message: etherscanData.message || "No transactions found from Etherscan",
        })
      }

const transactions = etherscanData.result || []
      console.log("[v0 API] Found", transactions.length, "transactions from Etherscan")

const cookieStore = await cookies()
      const supabase = createServerClient(
        process.env.NEXT_PUBLIC_SUPABASE_URL!,
        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
        {
          cookies: {
            getAll() {
              return cookieStore.getAll()
            },
            setAll(cookiesToSet) {
              cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
            },
          },
        },
      )

// Get current user (optional - transactions work without auth)
      const {
        data: { user },
      } = await supabase.auth.getUser()
      console.log("[v0 API] User authenticated:", !!user)

let savedCount = 0
      const lowerWalletAddress = walletAddress.toLowerCase()

for (const tx of transactions) {
        // Check if transaction already exists
        const { data: existing, error: checkError } = await supabase
          .from("transactions")
          .select("id")
          .eq("tx_hash", tx.hash)
          .maybeSingle()

if (checkError) {
          console.error("[v0 API] Error checking existing transaction:", checkError)
          continue
        }

if (existing) {
          console.log("[v0 API] Transaction already exists:", tx.hash)
          continue
        }

// Determine transaction type
        const type = tx.from.toLowerCase() === lowerWalletAddress ? "send" : "receive"
        console.log("[v0 API] Processing new transaction:", tx.hash, "type:", type)

// Save to database
        const { data, error } = await supabase
          .from("transactions")
          .insert({
            user_id: user?.id || null,
            tx_hash: tx.hash,
            from_address: tx.from,
            to_address: tx.to,
            amount: Number.parseFloat(tx.value) / 1e18, // Convert wei to ETH
            token: "ETH",
            type: type,
            status: tx.txreceipt_status === "1" ? "confirmed" : "failed",
            confirmed_at: new Date(Number.parseInt(tx.timeStamp) * 1000).toISOString(),
            created_at: new Date(Number.parseInt(tx.timeStamp) * 1000).toISOString(),
          })
          .select()
          .single()

if (error) {
          console.error("[v0 API] Error saving transaction:", error)
        } else {
          console.log("[v0 API] Successfully saved transaction:", tx.hash, type)
          savedCount++
        }
      }

console.log("[v0 API] Scan complete:", savedCount, "new transactions saved out of", transactions.length, "found")

return NextResponse.json({
        success: true,
        savedCount,
        totalFound: transactions.length,
        message: `Found ${savedCount} new transaction${savedCount !== 1 ? "s" : ""}`,
      })
    } catch (fetchError: any) {
      if (fetchError.name === "AbortError") {
        console.error("[v0 API] Request timed out")
        throw new Error("Request timed out")
      }
      throw fetchError
    }
  } catch (error: any) {
    console.error("[v0 API] Error in scan endpoint:", error.message || error)
    return NextResponse.json(
      {
        error: "Failed to scan transactions",
        details: error.message,
      },
      { status: 500 },
    )
  }
}
[V0_FILE]typescript:file="app/api/transactions/scan-blockchain/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"
import { ethers } from "ethers"

export async function POST(request: Request) {
  try {
    const { walletAddress } = await request.json()

if (!walletAddress) {
      return NextResponse.json({ error: "Wallet address required" }, { status: 400 })
    }

console.log("[v0 Blockchain Scan] Starting scan for:", walletAddress)

const provider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")

const currentBlock = await provider.getBlockNumber()
    console.log("[v0 Blockchain Scan] Current block:", currentBlock)

const cookieStore = await cookies()
    const supabase = createServerClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
      {
        cookies: {
          getAll() {
            return cookieStore.getAll()
          },
          setAll(cookiesToSet) {
            cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
          },
        },
      },
    )

const {
      data: { user },
    } = await supabase.auth.getUser()

let savedCount = 0
    const lowerWalletAddress = walletAddress.toLowerCase()

const blocksToScan = Math.min(1000, currentBlock)
    const startBlock = currentBlock - blocksToScan

console.log(`[v0 Blockchain Scan] Scanning blocks ${startBlock} to ${currentBlock}`)

for (let i = currentBlock; i >= startBlock; i--) {
      try {
        const block = await provider.getBlock(i, true)

if (!block || !block.transactions) continue

// Check each transaction in the block
        for (const txHash of block.transactions) {
          if (typeof txHash === "string") {
            const tx = await provider.getTransaction(txHash)

if (!tx || !tx.to) continue

// Check if this transaction is TO our wallet (incoming)
            if (tx.to.toLowerCase() === lowerWalletAddress) {
              console.log("[v0 Blockchain Scan] Found incoming transaction:", tx.hash)

// Check if already exists
              const { data: existing } = await supabase
                .from("transactions")
                .select("id")
                .eq("tx_hash", tx.hash)
                .maybeSingle()

if (existing) {
                console.log("[v0 Blockchain Scan] Transaction already exists:", tx.hash)
                continue
              }

// Get transaction receipt for status
              const receipt = await provider.getTransactionReceipt(tx.hash)
              const status = receipt?.status === 1 ? "confirmed" : "failed"

// Save to database
              const { error } = await supabase.from("transactions").insert({
                user_id: user?.id || null,
                tx_hash: tx.hash,
                from_address: tx.from,
                to_address: tx.to,
                amount: Number.parseFloat(ethers.formatEther(tx.value)),
                token: "ETH",
                type: "receive",
                status: status,
                confirmed_at: new Date(block.timestamp * 1000).toISOString(),
                created_at: new Date().toISOString(),
              })

if (error) {
                console.error("[v0 Blockchain Scan] Error saving:", error)
              } else {
                console.log("[v0 Blockchain Scan] Saved incoming transaction:", tx.hash)
                savedCount++
              }
            }
          }
        }

// Log progress every 100 blocks
        if (i % 100 === 0) {
          console.log(`[v0 Blockchain Scan] Progress: block ${i}, found ${savedCount} new transactions`)
        }
      } catch (blockError) {
        console.error(`[v0 Blockchain Scan] Error scanning block ${i}:`, blockError)
        // Continue with next block
      }
    }

console.log(`[v0 Blockchain Scan] Complete: ${savedCount} new incoming transactions saved`)

return NextResponse.json({
      success: true,
      savedCount,
      blocksScanned: blocksToScan,
      message: `Found ${savedCount} new incoming transaction${savedCount !== 1 ? "s" : ""}`,
    })
  } catch (error: any) {
    console.error("[v0 Blockchain Scan] Error:", error)
    return NextResponse.json(
      {
        error: "Failed to scan blockchain",
        details: error.message,
      },
      { status: 500 },
    )
  }
}
[V0_FILE]typescriptreact:file="components/admin-layout.tsx" isMerged="true"
"use client"

import type React from "react"

import { useRouter, usePathname } from "next/navigation"
import Link from "next/link"
import { useEffect, useState } from "react"
import { LayoutDashboard, Users, DollarSign, ArrowLeftRight, Settings, LogOut, Menu, X } from "lucide-react"
import { Button } from "@/components/ui/button"

const navigation = [
  { name: "Dashboard", href: "/admin", icon: LayoutDashboard },
  { name: "Users", href: "/admin/users", icon: Users },
  { name: "Transactions", href: "/admin/transactions", icon: ArrowLeftRight },
  { name: "Commissions", href: "/admin/commissions", icon: DollarSign },
  { name: "Settings", href: "/admin/settings", icon: Settings },
]

export function AdminLayout({ children }: { children: React.ReactNode }) {
  const router = useRouter()
  const pathname = usePathname()
  const [sidebarOpen, setSidebarOpen] = useState(false)

useEffect(() => {
    const token = sessionStorage.getItem("admin_auth")
    if (!token && pathname !== "/admin/login") {
      router.push("/admin/login")
    }
  }, [pathname, router])

const handleLogout = () => {
    sessionStorage.removeItem("admin_auth")
    router.push("/admin/login")
  }

if (pathname === "/admin/login") {
    return <>{children}</>
  }

return (
    <div className="min-h-screen bg-gray-50">
      {/* Mobile sidebar backdrop */}
      {sidebarOpen && (
        <div className="fixed inset-0 bg-gray-900/50 z-40 lg:hidden" onClick={() => setSidebarOpen(false)} />
      )}

{/* Sidebar */}
      <aside
        className={`fixed top-0 left-0 z-50 h-full w-64 bg-white border-r border-gray-200 transform transition-transform duration-200 ease-in-out lg:translate-x-0 ${
          sidebarOpen ? "translate-x-0" : "-translate-x-full"
        }`}
      >
        <div className="flex flex-col h-full">
          {/* Logo */}
          <div className="flex items-center justify-between h-16 px-6 border-b border-gray-200">
            <h1 className="text-xl font-bold text-gray-900">LinkFi Admin</h1>
            <button onClick={() => setSidebarOpen(false)} className="lg:hidden">
              <X className="w-6 h-6 text-gray-500" />
            </button>
          </div>

{/* Navigation */}
          <nav className="flex-1 px-4 py-6 space-y-1 overflow-y-auto">
            {navigation.map((item) => {
              const isActive = pathname === item.href
              return (
                <Link
                  key={item.name}
                  href={item.href}
                  onClick={() => setSidebarOpen(false)}
                  className={`flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-lg transition-colors ${
                    isActive ? "bg-blue-50 text-blue-700" : "text-gray-700 hover:bg-gray-50 hover:text-gray-900"
                  }`}
                >
                  <item.icon className="w-5 h-5" />
                  {item.name}
                </Link>
              )
            })}
          </nav>

{/* Logout */}
          <div className="p-4 border-t border-gray-200">
            <Button variant="outline" onClick={handleLogout} className="w-full justify-start gap-3 bg-transparent">
              <LogOut className="w-5 h-5" />
              Logout
            </Button>
          </div>
        </div>
      </aside>

{/* Main content */}
      <div className="lg:pl-64">
        {/* Top bar */}
        <header className="sticky top-0 z-30 h-16 bg-white border-b border-gray-200">
          <div className="flex items-center justify-between h-full px-4 lg:px-8">
            <button onClick={() => setSidebarOpen(true)} className="lg:hidden">
              <Menu className="w-6 h-6 text-gray-700" />
            </button>
            <div className="flex items-center gap-4 ml-auto">
              <span className="text-sm text-gray-600">Admin Panel</span>
            </div>
          </div>
        </header>

{/* Page content */}
        <main className="p-4 lg:p-8">{children}</main>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/admin/users/page.tsx" isMerged="true"
"use client"

import { useEffect, useState } from "react"
import { AdminLayout } from "@/components/admin-layout"
import { Card, CardContent, CardHeader } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { createClient } from "@/lib/supabase/client"
import { Search, User } from "lucide-react"

interface UserProfile {
  id: string
  username: string
  display_name: string
  wallet_address: string
  builtin_wallet_address: string
  created_at: string
}

export default function AdminUsersPage() {
  const [users, setUsers] = useState<UserProfile[]>([])
  const [filteredUsers, setFilteredUsers] = useState<UserProfile[]>([])
  const [searchQuery, setSearchQuery] = useState("")
  const [loading, setLoading] = useState(true)

useEffect(() => {
    loadUsers()
  }, [])

useEffect(() => {
    if (searchQuery) {
      const filtered = users.filter(
        (user) =>
          user.username?.toLowerCase().includes(searchQuery.toLowerCase()) ||
          user.display_name?.toLowerCase().includes(searchQuery.toLowerCase()) ||
          user.wallet_address?.toLowerCase().includes(searchQuery.toLowerCase()),
      )
      setFilteredUsers(filtered)
    } else {
      setFilteredUsers(users)
    }
  }, [searchQuery, users])

const loadUsers = async () => {
    try {
      const supabase = createClient()

const { data, error } = await supabase.from("profiles").select("*").order("created_at", { ascending: false })

if (error) throw error
      setUsers(data || [])
      setFilteredUsers(data || [])
    } catch (error) {
      console.error("Failed to load users:", error)
    } finally {
      setLoading(false)
    }
  }

return (
    <AdminLayout>
      <div className="space-y-6">
        <div>
          <h1 className="text-3xl font-bold text-gray-900">User Management</h1>
          <p className="text-gray-600 mt-1">View and manage all registered users</p>
        </div>

<div className="bg-blue-50 border border-blue-200 rounded-lg p-4">
          <p className="text-sm text-blue-800">
            <strong>Total Users:</strong> {filteredUsers.length} {searchQuery && `(filtered from ${users.length})`}
          </p>
        </div>
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescriptreact:file="app/admin/users/loading.tsx" isFixed="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/admin/transactions/loading.tsx" isFixed="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/admin/commissions/loading.tsx" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/admin/settings/loading.tsx" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="app/admin/loading.tsx" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescript:file="lib/networks.ts" isEdit="true" isQuickEdit="true" isMerged="true"
export interface Network {
  id: string
  name: string
  chainId: number
  chainIdHex: string
  symbol: string
  rpcUrl: string
  blockExplorerUrl: string
  icon: string
  color: string
}

export const NETWORKS: Record<string, Network> = {
  ethereum: {
    id: "ethereum",
    name: "Ethereum",
    chainId: 1,
    chainIdHex: "0x1",
    symbol: "ETH",
    rpcUrl: "https://eth.llamarpc.com",
    blockExplorerUrl: "https://etherscan.io",
    icon: "⟠",
    color: "#627EEA",
  },
  sepolia: {
    id: "sepolia",
    name: "Sepolia",
    chainId: 11155111,
    chainIdHex: "0xaa36a7",
    symbol: "ETH",
    rpcUrl: "https://rpc.sepolia.org",
    blockExplorerUrl: "https://sepolia.etherscan.io",
    icon: "⟠",
    color: "#627EEA",
  },
  arbitrum: {
    id: "arbitrum",
    name: "Arbitrum One",
    chainId: 42161,
    chainIdHex: "0xa4b1",
    symbol: "ETH",
    rpcUrl: "https://arb1.arbitrum.io/rpc",
    blockExplorerUrl: "https://arbiscan.io",
    icon: "🔷",
    color: "#28A0F0",
  },
  base: {
    id: "base",
    name: "Base",
    chainId: 8453,
    chainIdHex: "0x2105",
    symbol: "ETH",
    rpcUrl: "https://mainnet.base.org",
    blockExplorerUrl: "https://basescan.org",
    icon: "🔵",
    color: "#0052FF",
  },
  polygon: {
    id: "polygon",
    name: "Polygon",
    chainId: 137,
    chainIdHex: "0x89",
    symbol: "MATIC",
    rpcUrl: "https://polygon-rpc.com",
    blockExplorerUrl: "https://polygonscan.com",
    icon: "⬣",
    color: "#8247E5",
  },
  bnb: {
    id: "bnb",
    name: "BNB Smart Chain",
    chainId: 56,
    chainIdHex: "0x38",
    symbol: "BNB",
    rpcUrl: "https://bsc-dataseed1.binance.org",
    blockExplorerUrl: "https://bscscan.com",
    icon: "🟡",
    color: "#F3BA2F",
  },
  optimism: {
    id: "optimism",
    name: "Optimism",
    chainId: 10,
    chainIdHex: "0xa",
    symbol: "ETH",
    rpcUrl: "https://mainnet.optimism.io",
    blockExplorerUrl: "https://optimistic.etherscan.io",
    icon: "🔴",
    color: "#FF0420",
  },
  avalanche: {
    id: "avalanche",
    name: "Avalanche",
    chainId: 43114,
    chainIdHex: "0xa86a",
    symbol: "AVAX",
    rpcUrl: "https://api.avax.network/ext/bc/C/rpc",
    blockExplorerUrl: "https://snowtrace.io",
    icon: "🔺",
    color: "#E84142",
  },
}

export const DEFAULT_NETWORK = NETWORKS.ethereum

export async function switchNetwork(provider: any, network: Network): Promise<boolean> {
  try {
    await provider.request({
      method: "wallet_switchEthereumChain",
      params: [{ chainId: network.chainIdHex }],
    })
    return true
  } catch (error: any) {
    // Chain not added to wallet, try to add it
    if (error.code === 4902) {
      try {
        await provider.request({
          method: "wallet_addEthereumChain",
          params: [
            {
              chainId: network.chainIdHex,
              chainName: network.name,
              nativeCurrency: {
                name: network.symbol,
                symbol: network.symbol,
                decimals: 18,
              },
              rpcUrls: [network.rpcUrl],
              blockExplorerUrls: [network.blockExplorerUrl],
            },
          ],
        })
        return true
      } catch (addError) {
        console.error("Error adding network:", addError)
        return false
      }
    }
    console.error("Error switching network:", error)
    return false
  }
}

export async function getCurrentNetwork(provider: any): Promise<Network | null> {
  try {
    const chainId = await provider.request({ method: "eth_chainId" })
    const chainIdDecimal = Number.parseInt(chainId, 16)

const network = Object.values(NETWORKS).find((n) => n.chainId === chainIdDecimal)
    return network || null
  } catch (error) {
    console.error("Error getting current network:", error)
    return null
  }
}
[V0_FILE]css:file="app/globals.css" isEdit="true" isQuickEdit="true" isMerged="true"
@import "tailwindcss";
@import "tw-animate-css";

@custom-variant dark (&:is(.dark *));

:root {
  --background: oklch(0.99 0 0);
  --foreground: oklch(0.09 0 0);
  --card: oklch(1 0 0);
  --card-foreground: oklch(0.09 0 0);
  --popover: oklch(1 0 0);
  --popover-foreground: oklch(0.09 0 0);
  --primary: oklch(0.09 0 0);
  --primary-foreground: oklch(0.99 0 0);
  --secondary: oklch(0.96 0 0);
  --secondary-foreground: oklch(0.09 0 0);
  --muted: oklch(0.96 0 0);
  --muted-foreground: oklch(0.5 0 0);
  --accent: oklch(0.96 0 0);
  --accent-foreground: oklch(0.09 0 0);
  --destructive: oklch(0.577 0.245 27.325);
  --destructive-foreground: oklch(0.99 0 0);
  --border: oklch(0.92 0 0);
  --input: oklch(0.92 0 0);
  --ring: oklch(0.09 0 0);
  --success: oklch(0.65 0.18 155);
  --radius: 0.75rem;
  --chart-1: oklch(0.646 0.222 41.116);
  --chart-2: oklch(0.6 0.118 184.704);
  --chart-3: oklch(0.398 0.07 227.392);
  --chart-4: oklch(0.828 0.189 84.429);
  --chart-5: oklch(0.769 0.188 70.08);
  --sidebar: oklch(0.985 0 0);
  --sidebar-foreground: oklch(0.145 0 0);
  --sidebar-primary: oklch(0.205 0 0);
  --sidebar-primary-foreground: oklch(0.985 0 0);
  --sidebar-accent: oklch(0.97 0 0);
  --sidebar-accent-foreground: oklch(0.205 0 0);
  --sidebar-border: oklch(0.922 0 0);
  --sidebar-ring: oklch(0.708 0 0);
}

.dark {
  --background: oklch(0.09 0 0);
  --foreground: oklch(0.99 0 0);
  --card: oklch(0.12 0 0);
  --card-foreground: oklch(0.99 0 0);
  --popover: oklch(0.12 0 0);
  --popover-foreground: oklch(0.99 0 0);
  --primary: oklch(0.99 0 0);
  --primary-foreground: oklch(0.09 0 0);
  --secondary: oklch(0.2 0 0);
  --secondary-foreground: oklch(0.99 0 0);
  --muted: oklch(0.2 0 0);
  --muted-foreground: oklch(0.6 0 0);
  --accent: oklch(0.2 0 0);
  --accent-foreground: oklch(0.99 0 0);
  --destructive: oklch(0.5 0.2 27.325);
  --destructive-foreground: oklch(0.99 0 0);
  --border: oklch(0.2 0 0);
  --input: oklch(0.2 0 0);
  --ring: oklch(0.7 0 0);
  --success: oklch(0.65 0.18 155);
  --chart-1: oklch(0.488 0.243 264.376);
  --chart-2: oklch(0.696 0.17 162.48);
  --chart-3: oklch(0.769 0.188 70.08);
  --chart-4: oklch(0.627 0.265 303.9);
  --chart-5: oklch(0.645 0.246 16.439);
  --sidebar: oklch(0.205 0 0);
  --sidebar-foreground: oklch(0.985 0 0);
  --sidebar-primary: oklch(0.488 0.243 264.376);
  --sidebar-primary-foreground: oklch(0.985 0 0);
  --sidebar-accent: oklch(0.269 0 0);
  --sidebar-accent-foreground: oklch(0.985 0 0);
  --sidebar-border: oklch(0.269 0 0);
  --sidebar-ring: oklch(0.439 0 0);
}

@theme inline {
  /* optional: --font-sans, --font-serif, --font-mono if they are applied in the layout.tsx */
  --font-sans: "Geist", "Geist Fallback";
  --font-mono: "Geist Mono", "Geist Mono Fallback";
  --color-background: var(--background);
  --color-foreground: var(--foreground);
  --color-card: var(--card);
  --color-card-foreground: var(--card-foreground);
  --color-popover: var(--popover);
  --color-popover-foreground: var(--popover-foreground);
  --color-primary: var(--primary);
  --color-primary-foreground: var(--primary-foreground);
  --color-secondary: var(--secondary);
  --color-secondary-foreground: var(--secondary-foreground);
  --color-muted: var(--muted);
  --color-muted-foreground: var(--muted-foreground);
  --color-accent: var(--accent);
  --color-accent-foreground: var(--accent-foreground);
  --color-destructive: var(--destructive);
  --color-destructive-foreground: var(--destructive-foreground);
  --color-border: var(--border);
  --color-input: var(--input);
  --color-ring: var(--ring);
  --color-success: var(--success);
  --radius-sm: calc(var(--radius) - 4px);
  --radius-md: calc(var(--radius) - 2px);
  --radius-lg: var(--radius);
  --radius-xl: calc(var(--radius) + 4px);
  --color-chart-1: var(--chart-1);
  --color-chart-2: var(--chart-2);
  --color-chart-3: var(--chart-3);
  --color-chart-4: var(--chart-4);
  --color-chart-5: var(--chart-5);
  --color-sidebar: var(--sidebar);
  --color-sidebar-foreground: var(--sidebar-foreground);
  --color-sidebar-primary: var(--sidebar-primary);
  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
  --color-sidebar-accent: var(--sidebar-accent);
  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
  --color-sidebar-border: var(--sidebar-border);
  --color-sidebar-ring: var(--sidebar-ring);
}

@layer base {
  * {
    @apply border-border outline-ring/50;
  }
  body {
    @apply bg-background text-foreground;
  }
}

/* Fixed ticker animation to be faster and more consistent */
/* Fixed animation to translate exactly 33.33% to match the 3x duplication for seamless infinite loop */
@keyframes scroll-ticker {
  from {
    transform: translateX(0);
  }
  to {
    transform: translateX(-33.333%);
  }
}

/* Increased speed to 50s and removed hover pause for truly constant flow */
.animate-scroll-ticker {
  display: flex;
  animation: scroll-ticker 50s linear infinite;
  will-change: transform;
}
[V0_FILE]sql:file="scripts/002-fix-profiles-rls-policy.sql" isMerged="true"
-- Drop the existing restrictive INSERT policy
DROP POLICY IF EXISTS profiles_insert_own ON profiles;

-- Create a new INSERT policy that allows users to create their own profile during signup
-- This checks if the user is authenticated AND the ID matches their auth.uid()
CREATE POLICY profiles_insert_own ON profiles
  FOR INSERT
  WITH CHECK (
    auth.uid() = id
  );

-- Also ensure authenticated users can insert even if session is brand new
-- by allowing service role to bypass (which the Supabase client uses during signup)
ALTER TABLE profiles ENABLE ROW LEVEL SECURITY;

-- Grant necessary permissions
GRANT INSERT ON profiles TO authenticated;
GRANT INSERT ON profiles TO service_role;
[V0_FILE]typescriptreact:file="app/reset-password/loading.tsx" isEdit="true" isMerged="true"
export default function Loading() {
  return null
}
[V0_FILE]typescriptreact:file="components/transaction-confirmation-modal.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { X, AlertCircle, Check } from "lucide-react"

interface TransactionConfirmationModalProps {
  isOpen: boolean
  onClose: () => void
  onConfirm: () => void
  recipient: string
  amount: string
  token: string
  gasFee: string
  gasFeeUsd: string
  totalCost: string
  totalCostUsd: string
}

export function TransactionConfirmationModal({
  isOpen,
  onClose,
  onConfirm,
  recipient,
  amount,
  token,
  gasFee,
  gasFeeUsd,
  totalCost,
  totalCostUsd,
}: TransactionConfirmationModalProps) {
  console.log("[v0 MODAL] TransactionConfirmationModal rendered", {
    isOpen,
    hasOnConfirm: typeof onConfirm === "function",
    recipient: recipient?.slice(0, 10) + "...",
    amount,
    token,
  })

if (!isOpen) {
    console.log("[v0 MODAL] Modal is closed, returning null")
    return null
  }

const handleConfirm = () => {
    console.log("[v0 MODAL] Confirm button clicked!")
    console.log("[v0 MODAL] onConfirm type:", typeof onConfirm)
    console.log("[v0 MODAL] Calling onConfirm...")
    try {
      onConfirm()
      console.log("[v0 MODAL] onConfirm called successfully")
    } catch (error) {
      console.error("[v0 MODAL] Error calling onConfirm:", error)
    }
  }

const handleTestClick = () => {
    console.log("[v0 MODAL] TEST BUTTON CLICKED - Button is responsive!")
  }

return (
    <div
      className="fixed inset-0 bg-black/80 flex items-center justify-center z-50 p-4 backdrop-blur-sm"
      onClick={(e) => {
        console.log("[v0 MODAL] Overlay clicked")
        if (e.target === e.currentTarget) {
          console.log("[v0 MODAL] Clicked outside modal, not closing to prevent accidental closes")
        }
      }}
    >
      <Card className="w-full max-w-md p-6 bg-card border-border shadow-2xl">
        <div className="flex items-center justify-between mb-6">
          <h3 className="text-xl font-bold text-foreground">Review Transaction</h3>
          <Button
            variant="ghost"
            size="icon"
            onClick={() => {
              console.log("[v0 MODAL] Close button clicked")
              onClose()
            }}
            className="h-8 w-8"
          >
            <X className="w-5 h-5" />
          </Button>
        </div>

<div className="space-y-4 mb-6">
          {/* Amount Section */}
          <div className="text-center py-6 bg-primary/5 rounded-lg border border-primary/20">
            <p className="text-sm text-muted-foreground mb-1">You're sending</p>
            <p className="text-3xl font-bold text-foreground">
              {amount} {token}
            </p>
          </div>

{/* Recipient */}
          <div className="space-y-1">
            <p className="text-sm font-medium text-muted-foreground">To</p>
            <p className="font-mono text-sm bg-muted p-3 rounded-lg break-all">{recipient}</p>
          </div>

{/* Fee Breakdown */}
          <div className="space-y-2 pt-4 border-t border-border">
            <div className="flex justify-between text-sm">
              <span className="text-muted-foreground">Amount</span>
              <span className="font-medium">
                {amount} {token}
              </span>
            </div>
            <div className="flex justify-between text-sm">
              <span className="text-muted-foreground">Network Fee</span>
              <div className="text-right">
                <span className="font-medium">{gasFee} ETH</span>
                <p className="text-xs text-muted-foreground">${gasFeeUsd}</p>
              </div>
            </div>
            <div className="flex justify-between text-base font-bold pt-2 border-t border-border">
              <span>Total Cost</span>
              <div className="text-right">
                <span>{totalCost}</span>
                <p className="text-sm font-normal text-muted-foreground">${totalCostUsd}</p>
              </div>
            </div>
          </div>

{/* Warning */}
          <div className="p-3 rounded-lg bg-amber-500/10 border border-amber-500/20">
            <div className="flex items-start gap-2">
              <AlertCircle className="w-4 h-4 text-amber-600 mt-0.5 flex-shrink-0" />
              <p className="text-xs text-foreground">
                This transaction cannot be reversed. Please verify all details before confirming.
              </p>
            </div>
          </div>
        </div>

<div className="flex gap-3">
          <Button
            variant="outline"
            onClick={() => {
              console.log("[v0 MODAL] Cancel button clicked")
              onClose()
            }}
            className="flex-1 bg-transparent"
          >
            Cancel
          </Button>
          <Button
            onClick={handleConfirm}
            onMouseDown={() => console.log("[v0 MODAL] Mouse down on Confirm button")}
            onMouseUp={() => console.log("[v0 MODAL] Mouse up on Confirm button")}
            onTouchStart={() => console.log("[v0 MODAL] Touch start on Confirm button")}
            onPointerDown={() => console.log("[v0 MODAL] Pointer down on Confirm button")}
            className="flex-1"
            type="button"
          >
            <Check className="w-4 h-4 mr-2" />
            Confirm Send
          </Button>
        </div>

<Button onClick={handleTestClick} className="w-full mt-2 bg-purple-600" type="button">
          TEST BUTTON (Click to verify buttons work)
        </Button>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="lib/wallet-sync.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { createClient } from "@/lib/supabase/client"
import { decryptWallet, generateWallet, type GeneratedWallet } from "./wallet-generator"

/**
 * Check if user has a wallet and sync it to localStorage
 */
export async function syncWalletFromCloud(): Promise<boolean> {
  try {
    const supabase = createClient()
    const {
      data: { user },
    } = await supabase.auth.getUser()

if (!user) return false

const { data: profile } = await supabase
      .from("profiles")
      .select("encrypted_wallet, builtin_wallet_address, has_builtin_wallet, encrypted_mnemonic")
      .eq("id", user.id)
      .single()

if (profile?.encrypted_wallet && profile?.has_builtin_wallet) {
      localStorage.setItem("linkficrypto_wallet", profile.encrypted_wallet)
      localStorage.setItem("linkficrypto_wallet_address", profile.builtin_wallet_address)
      if (profile.encrypted_mnemonic) {
        localStorage.setItem("linkficrypto_mnemonic", profile.encrypted_mnemonic)
      }
      return true
    }

return false
  } catch (err) {
    console.error("[v0] Wallet sync error:", err)
    return false
  }
}

/**
 * Check if user has a wallet stored locally or in cloud
 */
export function hasWallet(): boolean {
  return !!localStorage.getItem("linkficrypto_wallet")
}

/**
 * Get wallet address if available
 */
export function getWalletAddress(): string | null {
  return localStorage.getItem("linkficrypto_wallet_address")
}

/**
 * Unlock wallet with password and return decrypted wallet
 */
export async function unlockWallet(password: string): Promise<GeneratedWallet | null> {
  try {
    const sessionUnlocked = sessionStorage.getItem("linkficrypto_wallet_unlocked")
    const sessionWallet = sessionStorage.getItem("linkficrypto_wallet_session")

if (sessionUnlocked === "true" && sessionWallet) {
      console.log("[v0] Using already unlocked wallet from session")
      return JSON.parse(sessionWallet)
    }

const encryptedWallet = localStorage.getItem("linkficrypto_wallet")
    if (!encryptedWallet) {
      // Try to sync from cloud
      await syncWalletFromCloud()
      const syncedWallet = localStorage.getItem("linkficrypto_wallet")
      if (!syncedWallet) return null

const decrypted = await decryptWallet(syncedWallet, password)

// Store in session for auto-unlock
      sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
      sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(decrypted))

return decrypted
    }

const decrypted = await decryptWallet(encryptedWallet, password)

// Store in session for auto-unlock
    sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
    sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(decrypted))

return decrypted
  } catch (err) {
    console.error("[v0] Wallet unlock error:", err)
    return null
  }
}

/**
 * Clear wallet session (for logout)
 */
export function clearWalletSession(): void {
  sessionStorage.removeItem("linkficrypto_wallet_unlocked")
  sessionStorage.removeItem("linkficrypto_wallet_session")
}

/**
 * Create a new wallet with encryption
 */
export function createWallet(password: string): {
  address: string
  privateKey: string
  encryptedWallet: string
  mnemonic: string
} {
  const wallet = generateWallet()

// Encrypt the wallet synchronously using CryptoJS for immediate use
  const CryptoJS = require("crypto-js")
  const encryptedWallet = CryptoJS.AES.encrypt(
    JSON.stringify({
      address: wallet.address,
      privateKey: wallet.privateKey,
      mnemonic: wallet.mnemonic,
    }),
    password,
  ).toString()

return {
    address: wallet.address,
    privateKey: wallet.privateKey,
    encryptedWallet,
    mnemonic: wallet.mnemonic,
  }
}

/**
 * Save encrypted wallet to cloud (Supabase)
 */
export async function saveWalletToCloud(encryptedWallet: string, userId: string, address: string): Promise<boolean> {
  try {
    const supabase = createClient()

const CryptoJS = require("crypto-js")

// The encrypted wallet should contain the address, but we don't decrypt it here
    // Instead, we'll update the function signature to require the address parameter

const { error } = await supabase
      .from("profiles")
      .update({
        encrypted_wallet: encryptedWallet,
        builtin_wallet_address: address,
        has_builtin_wallet: true,
        updated_at: new Date().toISOString(),
      })
      .eq("id", userId)

if (error) throw error

return true
  } catch (err) {
    console.error("[v0] Error saving wallet to cloud:", err)
    return false
  }
}
[V0_FILE]typescriptreact:file="app/reset-password/page.tsx" isEdit="true" isMerged="true"
"use client"

import type React from "react"

import { useState, useEffect } from "react"
import { useRouter } from "next/navigation"
import { createClient } from "@/lib/supabase/client"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Eye, EyeOff, Loader2, Wallet } from "lucide-react"

export default function ResetPasswordPage() {
  const [password, setPassword] = useState("")
  const [confirmPassword, setConfirmPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState("")
  const [success, setSuccess] = useState(false)
  const router = useRouter()
  const supabase = createClient()

useEffect(() => {
    // Check if we have a valid session from the reset link
    supabase.auth.getSession().then(({ data: { session } }) => {
      if (!session) {
        setError("Invalid or expired reset link. Please request a new one.")
      }
    })
  }, [supabase.auth])

const handleResetPassword = async (e: React.FormEvent) => {
    e.preventDefault()
    setError("")
    setIsLoading(true)

try {
      if (!password || !confirmPassword) {
        setError("Please fill in all fields")
        setIsLoading(false)
        return
      }

if (password.length < 6) {
        setError("Password must be at least 6 characters")
        setIsLoading(false)
        return
      }

if (password !== confirmPassword) {
        setError("Passwords do not match")
        setIsLoading(false)
        return
      }

const {
        data: { user },
      } = await supabase.auth.getUser()

if (!user) {
        setError("No user session found. Please request a new reset link.")
        setIsLoading(false)
        return
      }

console.log("[v0 RESET] Resetting password for user:", user.id)

// Update password in Supabase Auth
      const { error: updateError } = await supabase.auth.updateUser({
        password: password,
      })

if (updateError) throw updateError

console.log("[v0 RESET] Password updated successfully")

console.log("[v0 RESET] Creating new wallet with ethers.js encryption...")
      const ethers = await import("ethers")

// Create a random wallet
      const wallet = ethers.Wallet.createRandom()
      console.log("[v0 RESET] New wallet created:", wallet.address)

// Encrypt using ethers' native encryption (web3 keystore format)
      console.log("[v0 RESET] Encrypting wallet with new password...")
      const encryptedWallet = await wallet.encrypt(password)
      console.log("[v0 RESET] Wallet encrypted successfully")

console.log("[v0 RESET] Updating profile with new encrypted wallet...")

// Update profile with new wallet
      const { error: profileError } = await supabase
        .from("profiles")
        .update({
          wallet_address: wallet.address,
          builtin_wallet_address: wallet.address,
          encrypted_wallet: encryptedWallet,
          has_builtin_wallet: true,
          updated_at: new Date().toISOString(),
        })
        .eq("id", user.id)

if (profileError) {
        console.error("[v0 RESET] Profile update error:", profileError)
        throw profileError
      }

console.log("[v0 RESET] Profile updated with new wallet")

// Store wallet session
      sessionStorage.setItem(
        "linkficrypto_wallet_session",
        JSON.stringify({
          address: wallet.address,
          privateKey: wallet.privateKey,
        }),
      )
      sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")

// Also store in localStorage
      localStorage.setItem("linkficrypto_wallet", encryptedWallet)
      localStorage.setItem("linkficrypto_wallet_address", wallet.address)

// Also set the backward compatible session storage key
      sessionStorage.setItem(
        "unlockedWallet",
        JSON.stringify({
          address: wallet.address,
          privateKey: wallet.privateKey,
        }),
      )

console.log("[v0 RESET] Password and wallet reset complete!")

setSuccess(true)

// Redirect to home after 2 seconds
      setTimeout(() => {
        router.push("/")
      }, 2000)
    } catch (error: any) {
      console.error("[v0 RESET] Password reset error:", error)
      setError(error.message || "Failed to reset password")
    } finally {
      setIsLoading(false)
    }
  }

return (
    <div className="min-h-screen flex items-center justify-center p-4 bg-background">
      <Card className="w-full max-w-md">
        <CardHeader className="text-center">
          <div className="flex justify-center mb-4">
            <div className="bg-primary/10 p-4 rounded-full">
              <Wallet className="w-8 h-8 text-primary" />
            </div>
          </div>
          <CardTitle className="text-2xl">Reset Your Password</CardTitle>
          <CardDescription>Enter your new password below. A new wallet will be created.</CardDescription>
        </CardHeader>
        <CardContent>
          {success ? (
            <div className="space-y-4">
              <div className="bg-green-50 dark:bg-green-950 p-4 rounded-lg">
                <p className="text-sm text-green-800 dark:text-green-200 text-center font-medium mb-2">
                  Password reset successfully!
                </p>
                <p className="text-xs text-green-700 dark:text-green-300 text-center">
                  A new wallet has been created and encrypted with your new password. Redirecting...
                </p>
              </div>
            </div>
          ) : (
            <form onSubmit={handleResetPassword} className="space-y-4">
              <div className="bg-amber-50 dark:bg-amber-950 p-3 rounded-lg">
                <p className="text-xs text-amber-800 dark:text-amber-200">
                  <strong>Note:</strong> Resetting your password will create a new wallet. Your old wallet will no
                  longer be accessible.
                </p>
              </div>

<div className="space-y-2">
                <Label htmlFor="password">New Password</Label>
                <div className="relative">
                  <Input
                    id="password"
                    type={showPassword ? "text" : "password"}
                    placeholder="At least 6 characters"
                    value={password}
                    onChange={(e) => setPassword(e.target.value)}
                    required
                  />
                  <button
                    type="button"
                    onClick={() => setShowPassword(!showPassword)}
                    className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                  >
                    {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                  </button>
                </div>
              </div>

<div className="space-y-2">
                <Label htmlFor="confirm-password">Confirm New Password</Label>
                <Input
                  id="confirm-password"
                  type={showPassword ? "text" : "password"}
                  placeholder="Re-enter your password"
                  value={confirmPassword}
                  onChange={(e) => setConfirmPassword(e.target.value)}
                  required
                />
              </div>

{error && <p className="text-sm text-destructive">{error}</p>}

<Button type="submit" className="w-full" disabled={isLoading}>
                {isLoading ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Resetting...
                  </>
                ) : (
                  "Reset Password & Create New Wallet"
                )}
              </Button>

<Button
                variant="outline"
                className="w-full bg-transparent"
                onClick={() => router.push("/")}
                type="button"
              >
                Back to Home
              </Button>
            </form>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/unified-auth-wallet.tsx" isMerged="true"
"use client"

import type React from "react"

import { useState } from "react"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { createClient } from "@/lib/supabase/client"
import { Eye, EyeOff, Loader2, Wallet } from "lucide-react"
import { useRouter } from "next/navigation"

interface UnifiedAuthWalletProps {
  onSuccess: () => void
}

export function UnifiedAuthWallet({ onSuccess }: UnifiedAuthWalletProps) {
  const [isLoading, setIsLoading] = useState(false)
  const [showPassword, setShowPassword] = useState(false)
  const [error, setError] = useState("")
  const [email, setEmail] = useState("")
  const [password, setPassword] = useState("")
  const [username, setUsername] = useState("")
  const [showPasswordReset, setShowPasswordReset] = useState(false)
  const [resetEmail, setResetEmail] = useState("")
  const [resetSuccess, setResetSuccess] = useState(false)
  const router = useRouter()
  const supabase = createClient()

const handleSignUp = async (e: React.FormEvent) => {
    e.preventDefault()
    setError("")
    setIsLoading(true)

try {
      console.log("[v0 SIGNUP] Starting signup process...")

// Validate input
      if (!email || !password || !username) {
        setError("Please fill in all fields")
        setIsLoading(false)
        return
      }

if (password.length < 6) {
        setError("Password must be at least 6 characters")
        setIsLoading(false)
        return
      }

console.log("[v0 SIGNUP] Checking if username exists:", username)

// Check if username is already taken (safe RPC; own-row RLS blocks direct cross-user reads)
      const { data: existingProfiles } = await supabase.rpc("get_profile_by_username", { uname: username })

if (existingProfiles && existingProfiles.length > 0) {
        setError("Username is already taken")
        setIsLoading(false)
        return
      }

console.log("[v0 SIGNUP] Username available, creating Supabase auth user...")

// Create Supabase account with username in metadata
      const { data: authData, error: signUpError } = await supabase.auth.signUp({
        email,
        password,
        options: {
          emailRedirectTo: process.env.NEXT_PUBLIC_DEV_SUPABASE_REDIRECT_URL || window.location.origin,
          data: {
            username: username,
          },
        },
      })

console.log("[v0 SIGNUP] Auth signup result:", {
        success: !!authData.user,
        userId: authData.user?.id,
        error: signUpError?.message,
      })

if (signUpError) throw signUpError

if (!authData.user) {
        setError("Failed to create account")
        setIsLoading(false)
        return
      }

console.log("[v0 SIGNUP] User created successfully, ID:", authData.user.id)

// Wait a moment for the trigger to execute
      await new Promise((resolve) => setTimeout(resolve, 1000))

console.log("[v0 SIGNUP] Checking if profile was created by trigger...")

// Check if profile exists
      const { data: profileCheck, error: profileCheckError } = await supabase
        .from("profiles")
        .select("id, username")
        .eq("id", authData.user.id)
        .single()

console.log("[v0 SIGNUP] Profile check result:", {
        exists: !!profileCheck,
        username: profileCheck?.username,
        error: profileCheckError?.message,
      })

console.log("[v0 SIGNUP] Creating wallet with ethers.js...")

const ethers = await import("ethers")

// Create a random wallet
      const wallet = ethers.Wallet.createRandom()
      console.log("[v0 SIGNUP] Wallet created:", wallet.address)

// Encrypt using ethers' native encryption (web3 keystore format)
      console.log("[v0 SIGNUP] Encrypting wallet...")
      const encryptedWallet = await wallet.encrypt(password)
      console.log("[v0 SIGNUP] Wallet encrypted successfully")

console.log("[v0 SIGNUP] Updating profile with wallet data...")

// Update the profile with wallet data
      const { error: profileError } = await supabase
        .from("profiles")
        .update({
          wallet_address: wallet.address,
          builtin_wallet_address: wallet.address,
          encrypted_wallet: encryptedWallet,
          has_builtin_wallet: true,
          updated_at: new Date().toISOString(),
        })
        .eq("id", authData.user.id)

console.log("[v0 SIGNUP] Profile update result:", {
        success: !profileError,
        error: profileError?.message,
      })

if (profileError) {
        console.error("[v0 SIGNUP] Profile update error:", profileError)
        throw profileError
      }

// Also store in localStorage
      localStorage.setItem("linkficrypto_wallet", encryptedWallet)
      localStorage.setItem("linkficrypto_wallet_address", wallet.address)

console.log("[v0 SIGNUP] SUCCESS! Account created with wallet:", wallet.address)

// Success
      onSuccess()
    } catch (error: any) {
      console.error("[v0 SIGNUP] ERROR:", error)
      setError(error.message || "Failed to create account")
    } finally {
      setIsLoading(false)
    }
  }

const handleSignIn = async (e: React.FormEvent) => {
    console.log("[v0 LOGIN] Form submitted!", { email, passwordLength: password?.length })

e.preventDefault()
    setError("")
    setIsLoading(true)

try {
      // Validate input
      if (!email || !password) {
        console.log("[v0 LOGIN] Validation failed - missing fields")
        setError("Please fill in all fields")
        setIsLoading(false)
        return
      }

console.log("[v0 LOGIN] Starting authentication with Supabase...")

// Sign in with Supabase
      const { data: authData, error: signInError } = await supabase.auth.signInWithPassword({
        email,
        password,
      })

console.log("[v0 LOGIN] Supabase response:", {
        hasUser: !!authData?.user,
        errorCode: signInError?.status,
        errorMessage: signInError?.message,
      })

if (signInError) throw signInError

if (!authData.user) {
        setError("Failed to sign in")
        setIsLoading(false)
        return
      }

console.log("[v0] Authenticated user:", authData.user.id)

const { data: profileData, error: profileError } = await supabase
        .from("profiles")
        .select("encrypted_wallet, builtin_wallet_address, has_builtin_wallet, wallet_address")
        .eq("id", authData.user.id)
        .single()

console.log("[v0] Profile data:", {
        hasEncryptedWallet: !!profileData?.encrypted_wallet,
        hasBuiltinWallet: profileData?.has_builtin_wallet,
        walletAddress: profileData?.wallet_address,
      })

if (profileError || !profileData) {
        console.error("[v0] Profile query error:", profileError)
        setError("Account found but wallet not linked. Please contact support.")
        setIsLoading(false)
        return
      }

const existingWalletAddress = profileData.wallet_address || profileData.builtin_wallet_address

const needsWalletCreation = !profileData.encrypted_wallet || !profileData.has_builtin_wallet

if (needsWalletCreation) {
        console.log("[v0] No encrypted wallet found, creating new wallet...")

if (existingWalletAddress) {
          console.error("[v0] Wallet address exists but encrypted wallet is missing. This indicates data corruption.")
          setError(
            "Your wallet data is corrupted. Please use 'Forgot password?' to reset your account and create a new wallet.",
          )
          setIsLoading(false)
          return
        }

try {
          const ethers = await import("ethers")

// Create a random wallet using ethers
          const wallet = ethers.Wallet.createRandom()
          console.log("[v0] Generated wallet address:", wallet.address)

// Encrypt the wallet using ethers' native encryption (web3 keystore format)
          console.log("[v0] Encrypting wallet with password...")
          const encryptedWallet = await wallet.encrypt(password)
          console.log("[v0] Wallet encrypted successfully")

// Save to database - ONLY if no wallet exists yet
          const { error: updateError } = await supabase
            .from("profiles")
            .update({
              encrypted_wallet: encryptedWallet,
              builtin_wallet_address: wallet.address,
              wallet_address: wallet.address,
              has_builtin_wallet: true,
              updated_at: new Date().toISOString(),
            })
            .eq("id", authData.user.id)

if (updateError) throw updateError

console.log("[v0] Wallet saved to database")

// Store wallet session
          sessionStorage.setItem(
            "linkficrypto_wallet_session",
            JSON.stringify({
              address: wallet.address,
              privateKey: wallet.privateKey,
            }),
          )
          sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")

// Also store in localStorage
          localStorage.setItem("linkficrypto_wallet", encryptedWallet)
          localStorage.setItem("linkficrypto_wallet_address", wallet.address)

// Also set the backward compatible session storage key
          sessionStorage.setItem(
            "unlockedWallet",
            JSON.stringify({
              address: wallet.address,
              privateKey: wallet.privateKey,
            }),
          )

console.log("[v0] Signed in with new wallet:", wallet.address)

// Success
          onSuccess()
          return
        } catch (createError: any) {
          console.error("[v0] Error creating wallet:", createError)
          setError("Failed to create wallet. Please try again.")
          setIsLoading(false)
          return
        }
      }

console.log("[v0] Found encrypted wallet, attempting to decrypt...")

try {
        const ethers = await import("ethers")

// Parse the encrypted wallet (it's a web3 keystore JSON)
        const keystoreJson =
          typeof profileData.encrypted_wallet === "string"
            ? profileData.encrypted_wallet
            : JSON.stringify(profileData.encrypted_wallet)

let normalizedKeystore = keystoreJson
        try {
          const parsed = JSON.parse(keystoreJson)
          // Web3.js uses "Crypto" but ethers.js expects "crypto"
          if (parsed.Crypto && !parsed.crypto) {
            parsed.crypto = parsed.Crypto
            delete parsed.Crypto
          }
          normalizedKeystore = JSON.stringify(parsed)
        } catch (parseError) {
          console.error("[v0] Error normalizing keystore:", parseError)
        }

console.log("[v0] Decrypting web3 keystore wallet...")

// Decrypt using ethers Wallet.fromEncryptedJson
        const wallet = await ethers.Wallet.fromEncryptedJson(normalizedKeystore, password)

console.log("[v0] Wallet decrypted successfully:", wallet.address)

// Store wallet session
        sessionStorage.setItem(
          "linkficrypto_wallet_session",
          JSON.stringify({
            address: wallet.address,
            privateKey: wallet.privateKey,
          }),
        )
        sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")

// Also store in localStorage for persistence
        localStorage.setItem("linkficrypto_wallet", keystoreJson)
        localStorage.setItem("linkficrypto_wallet_address", wallet.address)

// Also set the backward compatible session storage key
        sessionStorage.setItem(
          "unlockedWallet",
          JSON.stringify({
            address: wallet.address,
            privateKey: wallet.privateKey,
          }),
        )

console.log("[v0] Signed in with wallet:", wallet.address)

// Success
        onSuccess()
      } catch (decryptError: any) {
        console.error("[v0] Decryption error:", decryptError.message || decryptError)

setError(
          "Cannot decrypt wallet with this password. Click 'Forgot password?' below to reset your password and create a new wallet.",
        )
        setIsLoading(false)
        return
      }
    } catch (error: any) {
      console.error("[v0] Sign in error:", error)
      setError(error.message || "Failed to sign in")
    } finally {
      setIsLoading(false)
    }
  }

const handlePasswordReset = async (e: React.FormEvent) => {
    e.preventDefault()
    setError("")
    setIsLoading(true)

try {
      if (!resetEmail) {
        setError("Please enter your email address")
        setIsLoading(false)
        return
      }

const { error: resetError } = await supabase.auth.resetPasswordForEmail(resetEmail, {
        redirectTo: `${window.location.origin}/reset-password`,
      })

if (resetError) throw resetError

setResetSuccess(true)
      setError("")
    } catch (error: any) {
      console.error("[v0] Password reset error:", error)
      setError(error.message || "Failed to send reset email")
    } finally {
      setIsLoading(false)
    }
  }

if (showPasswordReset) {
    return (
      <Card className="w-full max-w-md mx-auto">
        <CardHeader className="text-center">
          <div className="flex justify-center mb-4">
            <div className="bg-primary/10 p-4 rounded-full">
              <Wallet className="w-8 h-8 text-primary" />
            </div>
          </div>
          <CardTitle className="text-2xl">Reset Password</CardTitle>
          <CardDescription>
            {resetSuccess
              ? "Check your email for reset instructions"
              : "Enter your email to receive a password reset link"}
          </CardDescription>
        </CardHeader>
        <CardContent>
          {resetSuccess ? (
            <div className="space-y-4">
              <div className="bg-green-50 dark:bg-green-950 p-4 rounded-lg">
                <p className="text-sm text-green-800 dark:text-green-200">
                  We've sent a password reset link to <strong>{resetEmail}</strong>. Check your email and follow the
                  instructions to reset your password.
                </p>
              </div>
              <Button
                variant="outline"
                className="w-full bg-transparent"
                onClick={() => {
                  setShowPasswordReset(false)
                  setResetSuccess(false)
                  setResetEmail("")
                }}
              >
                Back to Sign In
              </Button>
            </div>
          ) : (
            <form onSubmit={handlePasswordReset} className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="reset-email">Email</Label>
                <Input
                  id="reset-email"
                  type="email"
                  placeholder="you@example.com"
                  value={resetEmail}
                  onChange={(e) => setResetEmail(e.target.value)}
                  required
                />
              </div>

{error && <p className="text-sm text-destructive">{error}</p>}

<Button type="submit" className="w-full" disabled={isLoading}>
                {isLoading ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Sending...
                  </>
                ) : (
                  "Send Reset Link"
                )}
              </Button>

<Button
                variant="ghost"
                className="w-full"
                onClick={() => {
                  setShowPasswordReset(false)
                  setError("")
                }}
                type="button"
              >
                Back to Sign In
              </Button>
            </form>
          )}
        </CardContent>
      </Card>
    )
  }

return (
    <Card className="w-full max-w-md mx-auto">
      <CardHeader className="text-center">
        <div className="flex justify-center mb-4">
          <div className="bg-primary/10 p-4 rounded-full">
            <Wallet className="w-8 h-8 text-primary" />
          </div>
        </div>
        <CardTitle className="text-2xl">Welcome to LinkFiCrypto</CardTitle>
        <CardDescription>One account for your wallet and payments</CardDescription>
      </CardHeader>
      <CardContent>
        <Tabs defaultValue="signin" className="w-full">
          <TabsList className="grid w-full grid-cols-2">
            <TabsTrigger value="signin">Sign In</TabsTrigger>
            <TabsTrigger value="signup">Create Account</TabsTrigger>
          </TabsList>

<TabsContent value="signin">
            <form onSubmit={handleSignIn} className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="signin-email">Email</Label>
                <Input
                  id="signin-email"
                  type="email"
                  placeholder="you@example.com"
                  value={email}
                  onChange={(e) => setEmail(e.target.value)}
                  required
                />
              </div>

<div className="space-y-2">
                <Label htmlFor="signin-password">Password</Label>
                <div className="relative">
                  <Input
                    id="signin-password"
                    type={showPassword ? "text" : "password"}
                    placeholder="Enter your password"
                    value={password}
                    onChange={(e) => setPassword(e.target.value)}
                    required
                  />
                  <button
                    type="button"
                    onClick={() => setShowPassword(!showPassword)}
                    className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                  >
                    {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                  </button>
                </div>
              </div>

{error && <p className="text-sm text-destructive">{error}</p>}

<Button type="submit" className="w-full" disabled={isLoading}>
                {isLoading ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Signing in...
                  </>
                ) : (
                  "Sign In"
                )}
              </Button>

<Button
                variant="link"
                className="w-full text-sm"
                onClick={() => {
                  setShowPasswordReset(true)
                  setResetEmail(email)
                  setError("")
                }}
                type="button"
              >
                Forgot password?
              </Button>
            </form>
          </TabsContent>

<TabsContent value="signup">
            <form onSubmit={handleSignUp} className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="signup-username">Username</Label>
                <Input
                  id="signup-username"
                  type="text"
                  placeholder="@yourname"
                  value={username}
                  onChange={(e) => setUsername(e.target.value.replace(/[^a-zA-Z0-9_]/g, ""))}
                  required
                />
                <p className="text-xs text-muted-foreground">Use this to receive payments from friends</p>
              </div>

<div className="space-y-2">
                <Label htmlFor="signup-email">Email</Label>
                <Input
                  id="signup-email"
                  type="email"
                  placeholder="you@example.com"
                  value={email}
                  onChange={(e) => setEmail(e.target.value)}
                  required
                />
              </div>

<div className="space-y-2">
                <Label htmlFor="signup-password">Password</Label>
                <div className="relative">
                  <Input
                    id="signup-password"
                    type={showPassword ? "text" : "password"}
                    placeholder="At least 6 characters"
                    value={password}
                    onChange={(e) => setPassword(e.target.value)}
                    required
                  />
                  <button
                    type="button"
                    onClick={() => setShowPassword(!showPassword)}
                    className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                  >
                    {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                  </button>
                </div>
                <p className="text-xs text-muted-foreground">This password encrypts your wallet</p>
              </div>

{error && <p className="text-sm text-destructive">{error}</p>}

<Button type="submit" className="w-full" disabled={isLoading}>
                {isLoading ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Creating account...
                  </>
                ) : (
                  "Create Account & Wallet"
                )}
              </Button>

<div className="bg-muted/50 p-3 rounded-lg space-y-2">
                <p className="text-xs font-medium">What you get:</p>
                <ul className="text-xs text-muted-foreground space-y-1 ml-4">
                  <li>✓ Secure built-in crypto wallet</li>
                  <li>✓ Send/receive with @username</li>
                  <li>✓ QR codes for payments</li>
                  <li>✓ Cloud wallet backup</li>
                </ul>
              </div>
            </form>
          </TabsContent>
        </Tabs>
      </CardContent>
    </Card>
  )
}
[V0_FILE]typescript:file="app/api/admin/auth/route.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { type NextRequest, NextResponse } from "next/server"

// Simple authentication endpoint
export async function POST(request: NextRequest) {
  try {
    const { password } = await request.json()

console.log("[v0 Admin Auth] Password length received:", password?.length)

// Get admin password from environment variable
    const adminPassword = process.env.ADMIN_PASSWORD

console.log("[v0 Admin Auth] Admin password configured:", !!adminPassword)
    console.log("[v0 Admin Auth] Admin password length:", adminPassword?.length)

if (!adminPassword) {
      return NextResponse.json(
        { error: "Admin password not configured. Please set ADMIN_PASSWORD environment variable." },
        { status: 500 },
      )
    }

// Verify password
    console.log("[v0 Admin Auth] Passwords match:", password === adminPassword)

if (password === adminPassword) {
      // Generate a simple token (in production, use JWT or more secure method)
      const token = Buffer.from(`admin:${Date.now()}`).toString("base64")

return NextResponse.json({
        success: true,
        token,
        message: "Authentication successful",
      })
    }

return NextResponse.json({ error: "Invalid password" }, { status: 401 })
  } catch (error) {
    console.error("[Admin Auth] Error:", error)
    return NextResponse.json({ error: "Authentication failed" }, { status: 500 })
  }
}

// Verify admin authentication
export async function GET(request: NextRequest) {
  try {
    const authHeader = request.headers.get("authorization")

if (!authHeader || !authHeader.startsWith("Bearer ")) {
      return NextResponse.json({ authenticated: false }, { status: 401 })
    }

// In production, verify the token properly
    return NextResponse.json({ authenticated: true })
  } catch (error) {
    return NextResponse.json({ authenticated: false }, { status: 401 })
  }
}
[V0_FILE]typescriptreact:file="app/admin/login/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true"
"use client"

import type React from "react"

import { useState } from "react"
import { useRouter } from "next/navigation"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"

export default function AdminLoginPage() {
  const router = useRouter()
  const [password, setPassword] = useState("")
  const [error, setError] = useState("")
  const [loading, setLoading] = useState(false)

const handleLogin = async (e: React.FormEvent) => {
    e.preventDefault()
    setError("")
    setLoading(true)

console.log("[v0 Admin Login] Attempting login with password length:", password.length)

try {
      const response = await fetch("/api/admin/auth", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ password }),
      })

const data = await response.json()

if (response.ok) {
        console.log("[v0 Admin Login] Authentication successful")
        // Store auth token in session storage
        sessionStorage.setItem("admin_auth", data.token)
        router.push("/admin/commissions")
      } else {
        console.log("[v0 Admin Login] Authentication failed:", data.error)
        setError(data.error || "Invalid credentials")
      }
    } catch (err) {
      setError("Failed to authenticate")
    } finally {
      setLoading(false)
    }
  }

return (
    <div className="min-h-screen flex items-center justify-center bg-gradient-to-br from-gray-50 to-gray-100 p-4">
      <Card className="w-full max-w-md">
        <CardHeader>
          <CardTitle className="text-2xl">Admin Login</CardTitle>
          <CardDescription>Enter your admin password to access the dashboard</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleLogin} className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="password">Admin Password</Label>
              <Input
                id="password"
                type="password"
                value={password}
                onChange={(e) => setPassword(e.target.value)}
                placeholder="Enter admin password"
                required
                autoFocus
              />
            </div>

{error && (
              <div className="bg-red-50 border border-red-200 text-red-800 px-4 py-3 rounded-lg text-sm">{error}</div>
            )}

<Button type="submit" className="w-full" disabled={loading}>
              {loading ? "Authenticating..." : "Login"}
            </Button>
          </form>

<div className="mt-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
            <p className="text-sm text-blue-800 font-medium mb-2">Setup Instructions:</p>
            <p className="text-xs text-blue-700">
              Add <code className="bg-blue-100 px-1 py-0.5 rounded">ADMIN_PASSWORD</code> to your environment variables
              in the Vercel project settings.
            </p>
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/transaction-history.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Badge } from "@/components/ui/badge"
import { ExternalLink, ArrowUpRight, ArrowDownLeft, Loader2, ChevronDown, ChevronUp } from "lucide-react"
import { createClient } from "@/lib/supabase/client"

interface Transaction {
  hash: string
  from: string
  to: string
  value: string
  timestamp: number
  status: "success" | "pending" | "failed"
  type: "send" | "receive"
}

interface TransactionHistoryProps {
  walletAddress: string
  provider: any
}

export function TransactionHistory({ walletAddress, provider }: TransactionHistoryProps) {
  const [transactions, setTransactions] = useState<Transaction[]>([])
  const [isLoading, setIsLoading] = useState(true)
  const [error, setError] = useState<string | null>(null)
  const [showAll, setShowAll] = useState(false)

const supabase = createClient()

useEffect(() => {
    console.log("[v0 TxHistory] Component mounted with wallet:", walletAddress)
    console.log("[v0 TxHistory] Provider available:", !!provider)
  }, [walletAddress, provider])

useEffect(() => {
    if (!walletAddress || walletAddress.length < 10) {
      console.log("[v0 TxHistory] Invalid wallet, skipping")
      setIsLoading(false)
      return
    }

console.log("[v0 TxHistory] Starting auto-detection for:", walletAddress)

// Initial load
    loadTransactions()
    detectIncomingTransactions()

// Auto-refresh every 30 seconds
    const refreshInterval = setInterval(loadTransactions, 30000)

// Auto-scan for incoming every 45 seconds
    const scanInterval = setInterval(detectIncomingTransactions, 45000)

return () => {
      clearInterval(refreshInterval)
      clearInterval(scanInterval)
    }
  }, [walletAddress])

const loadTransactions = async () => {
    if (!walletAddress) return

setError(null)

try {
      console.log("[v0 TxHistory] Loading transactions from DB for:", walletAddress)

const lowerAddress = walletAddress.toLowerCase()

const { data, error: dbError } = await supabase
        .from("transactions")
        .select("*")
        .or(`from_address.ilike.${lowerAddress},to_address.ilike.${lowerAddress}`)
        .order("created_at", { ascending: false })
        .limit(100)

if (dbError) {
        console.error("[v0 TxHistory] DB Error:", dbError)
        throw dbError
      }

console.log("[v0 TxHistory] Found", data?.length || 0, "transactions")

const txs: Transaction[] =
        data?.map((tx) => {
          const type = tx.from_address.toLowerCase() === lowerAddress ? "send" : "receive"

console.log(
            "[v0 TxHistory] -",
            type.toUpperCase(),
            ":",
            tx.tx_hash?.substring(0, 10),
            tx.amount,
            "ETH",
            type === "send" ? `to ${tx.to_address.substring(0, 10)}` : `from ${tx.from_address.substring(0, 10)}`,
          )

return {
            hash: tx.tx_hash,
            from: tx.from_address,
            to: tx.to_address,
            value: tx.amount.toString(),
            timestamp: new Date(tx.created_at).getTime(),
            status:
              tx.status === "confirmed" || tx.status === "success"
                ? "success"
                : tx.status === "pending"
                  ? "pending"
                  : "failed",
            type,
          }
        }) || []

console.log(
        "[v0 TxHistory] Processed transactions - Send:",
        txs.filter((t) => t.type === "send").length,
        ", Receive:",
        txs.filter((t) => t.type === "receive").length,
      )

setTransactions(txs)
      setIsLoading(false)
    } catch (error: any) {
      console.error("[v0 TxHistory] Load error:", error)
      setError("Unable to load transactions")
      setTransactions([])
      setIsLoading(false)
    }
  }

const detectIncomingTransactions = async () => {
    if (!walletAddress) return

try {
      console.log("[v0 TxHistory] Scanning for incoming transactions...")

const response = await fetch("/api/transactions/detect-received", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ walletAddress }),
      })

const data = await response.json()
      console.log("[v0 TxHistory] Scan result:", data.savedCount, "new transactions")

if (response.ok && data.savedCount > 0) {
        console.log("[v0 TxHistory] Reloading transactions...")
        await loadTransactions()
      }
    } catch (error: any) {
      console.error("[v0 TxHistory] Scan error:", error)
    }
  }

const formatAddress = (address: string) => {
    return `${address.slice(0, 6)}...${address.slice(-4)}`
  }

const formatTime = (timestamp: number) => {
    const date = new Date(timestamp)
    const now = Date.now()
    const diff = now - timestamp

if (diff < 60000) return "Just now"
    if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`
    if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`
    return date.toLocaleDateString()
  }

const displayedTransactions = showAll ? transactions : transactions.slice(0, 5)
  const hasMore = transactions.length > 5

return (
    <Card className="p-6">
      <div className="flex items-center justify-between mb-6">
        <h3 className="text-lg font-semibold">Transaction History</h3>
        {isLoading && <Loader2 className="w-4 h-4 animate-spin text-muted-foreground/40" />}
      </div>

<div className="space-y-3">
        {isLoading && transactions.length === 0 ? (
          <div className="text-center py-8 text-muted-foreground">
            <Loader2 className="w-8 h-8 animate-spin mx-auto mb-2" />
            <p>Loading transactions...</p>
          </div>
        ) : error ? (
          <div className="text-center py-8 text-muted-foreground">
            <p className="text-destructive">{error}</p>
          </div>
        ) : transactions.length === 0 ? (
          <div className="text-center py-8 text-muted-foreground">
            <p>No transactions yet</p>
          </div>
        ) : (
          <>
            {displayedTransactions.map((tx) => (
              <div key={tx.hash} className="flex items-center justify-between p-4 border rounded-lg hover:bg-accent/50">
                <div className="flex items-center gap-3">
                  <div
                    className={`w-10 h-10 rounded-full flex items-center justify-center ${
                      tx.type === "send" ? "bg-destructive/10" : "bg-primary/10"
                    }`}
                  >
                    {tx.type === "send" ? (
                      <ArrowUpRight className="w-5 h-5 text-destructive" />
                    ) : (
                      <ArrowDownLeft className="w-5 h-5 text-primary" />
                    )}
                  </div>
                  <div>
                    <div className="flex items-center gap-2">
                      <p className="font-medium capitalize">{tx.type}</p>
                      <Badge variant={tx.status === "success" ? "default" : "secondary"}>{tx.status}</Badge>
                    </div>
                    <p className="text-sm text-muted-foreground">
                      {tx.type === "send" ? `To: ${formatAddress(tx.to)}` : `From: ${formatAddress(tx.from)}`}
                    </p>
                  </div>
                </div>
                <div className="flex items-center gap-3">
                  <div className="text-right">
                    <p className="font-medium">
                      {tx.type === "send" ? "-" : "+"}
                      {tx.value} ETH
                    </p>
                    <p className="text-sm text-muted-foreground">{formatTime(tx.timestamp)}</p>
                  </div>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="h-8 w-8 p-0"
                    onClick={() => window.open(`https://etherscan.io/tx/${tx.hash}`, "_blank")}
                  >
                    <ExternalLink className="w-4 h-4" />
                  </Button>
                </div>
              </div>
            ))}

{hasMore && (
              <Button variant="outline" className="w-full mt-4 bg-transparent" onClick={() => setShowAll(!showAll)}>
                {showAll ? (
                  <>
                    <ChevronUp className="w-4 h-4 mr-2" />
                    Show Less
                  </>
                ) : (
                  <>
                    <ChevronDown className="w-4 h-4 mr-2" />
                    View All ({transactions.length} transactions)
                  </>
                )}
              </Button>
            )}
          </>
        )}
      </div>
    </Card>
  )
}
[V0_FILE]sql:file="scripts/005_create_commission_payouts.sql" isMerged="true"
-- Create commission_payouts table to track automatic payouts
CREATE TABLE IF NOT EXISTS commission_payouts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  payout_amount NUMERIC NOT NULL,
  token TEXT NOT NULL DEFAULT 'ETH',
  destination_wallet TEXT NOT NULL,
  tx_hash TEXT,
  status TEXT NOT NULL DEFAULT 'pending', -- 'pending', 'processing', 'completed', 'failed'
  commission_ids UUID[] NOT NULL, -- Array of commission_earnings IDs included in this payout
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  processed_at TIMESTAMP WITH TIME ZONE,
  error_message TEXT,
  metadata JSONB DEFAULT '{}'::jsonb
);

-- Create index for faster queries
CREATE INDEX IF NOT EXISTS idx_commission_payouts_status ON commission_payouts(status);
CREATE INDEX IF NOT EXISTS idx_commission_payouts_created_at ON commission_payouts(created_at DESC);

-- Add RLS policies
ALTER TABLE commission_payouts ENABLE ROW LEVEL SECURITY;

-- Only admins can view and manage payouts
CREATE POLICY commission_payouts_admin_all ON commission_payouts
  FOR ALL
  TO authenticated
  USING (
    EXISTS (
      SELECT 1 FROM profiles
      WHERE profiles.id = auth.uid()
      AND profiles.username = 'LINKFICRYPTO'
    )
  );

-- Add payout_id column to commission_earnings to track which payout included this commission
ALTER TABLE commission_earnings ADD COLUMN IF NOT EXISTS payout_id UUID REFERENCES commission_payouts(id);
CREATE INDEX IF NOT EXISTS idx_commission_earnings_payout_id ON commission_earnings(payout_id);

COMMENT ON TABLE commission_payouts IS 'Tracks automatic commission payouts to admin wallet';
COMMENT ON COLUMN commission_payouts.commission_ids IS 'Array of commission_earnings IDs included in this payout batch';
COMMENT ON COLUMN commission_earnings.payout_id IS 'Reference to the payout that included this commission';
[V0_FILE]typescript:file="lib/commission-config.ts" isMerged="true"
// Commission configuration - 1inch wallet address for receiving platform fees
export const COMMISSION_WALLET_ADDRESS = "0x977967e0B4aF4fD746e65572461cb6a1F191dDd2" // Your 1inch wallet

export const COMMISSION_RATE = 0.01 // 1% commission on transactions

// Minimum commission amount in ETH (to avoid dust transactions)
export const MIN_COMMISSION_AMOUNT = 0.00001 // 0.00001 ETH minimum

export const MIN_PAYOUT_THRESHOLD = 0.001 // Only process payouts when total reaches 0.001 ETH

// Commission status types
export type CommissionStatus = "pending" | "paid" | "failed" | "processing"

// Helper to validate Ethereum address
export function isValidEthAddress(address: string): boolean {
  return /^0x[a-fA-F0-9]{40}$/.test(address)
}

// Get commission wallet info
export function getCommissionWalletInfo() {
  return {
    address: COMMISSION_WALLET_ADDRESS,
    rate: COMMISSION_RATE,
    ratePercent: COMMISSION_RATE * 100,
    minAmount: MIN_COMMISSION_AMOUNT,
    minPayout: MIN_PAYOUT_THRESHOLD,
    isValid: isValidEthAddress(COMMISSION_WALLET_ADDRESS),
    shortAddress: `${COMMISSION_WALLET_ADDRESS.slice(0, 6)}...${COMMISSION_WALLET_ADDRESS.slice(-4)}`,
  }
}
[V0_FILE]typescript:file="app/api/admin/commission-payout/route.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"
import { ethers } from "ethers"
import { COMMISSION_WALLET_ADDRESS } from "@/lib/commission-config"

export async function POST(request: Request) {
  try {
    const adminPassword = request.headers.get("x-admin-password")
    console.log("[v0 PAYOUT] Admin password header received:", adminPassword ? "Present" : "Missing")

if (!adminPassword) {
      console.log("[v0 PAYOUT] No admin password provided")
      return NextResponse.json({ error: "Admin access required", message: "Password required" }, { status: 403 })
    }

const expectedPassword = process.env.ADMIN_PASSWORD
    console.log("[v0 PAYOUT] Env admin password exists:", !!expectedPassword)
    console.log("[v0 PAYOUT] Password matches:", adminPassword === expectedPassword)

if (adminPassword !== expectedPassword) {
      console.log("[v0 PAYOUT] Invalid admin password")
      return NextResponse.json({ error: "Admin access required", message: "Invalid password" }, { status: 403 })
    }

console.log("[v0 PAYOUT] Admin authenticated successfully")

const body = await request.json()
    const { amount, destinationWallet, privateKey } = body

if (!privateKey) {
      return NextResponse.json({ error: "Private key required" }, { status: 400 })
    }

console.log("[v0 PAYOUT] Starting commission payout:", amount, "ETH to", destinationWallet)

try {
      const provider = new ethers.JsonRpcProvider(process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL!)

const wallet = new ethers.Wallet(privateKey, provider)

console.log("[v0 PAYOUT] Sending from wallet:", wallet.address)

// Send transaction
      const tx = await wallet.sendTransaction({
        to: destinationWallet,
        value: ethers.parseEther(amount.toString()),
      })

console.log("[v0 PAYOUT] Transaction sent:", tx.hash)

// Wait for confirmation
      const receipt = await tx.wait()

console.log("[v0 PAYOUT] Transaction confirmed:", receipt?.hash)

const cookieStore = await cookies()
      const supabase = createServerClient(
        process.env.NEXT_PUBLIC_SUPABASE_URL!,
        process.env.SUPABASE_SERVICE_ROLE_KEY!,
        {
          cookies: {
            getAll() {
              return cookieStore.getAll()
            },
            setAll(cookiesToSet) {
              try {
                cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
              } catch {}
            },
          },
        },
      )

await supabase.from("commission_payouts").insert({
        payout_amount: amount,
        token: "ETH",
        destination_wallet: destinationWallet,
        status: "completed",
        tx_hash: receipt?.hash,
        processed_at: new Date().toISOString(),
      })

return NextResponse.json({
        success: true,
        txHash: receipt?.hash,
        amount,
        destinationWallet,
      })
    } catch (txError: any) {
      console.error("[v0 PAYOUT] Transaction failed:", txError)

await supabase.from("commission_payouts").insert({
        payout_amount: amount,
        token: "ETH",
        destination_wallet: destinationWallet,
        status: "failed",
        error_message: txError.message,
        processed_at: new Date().toISOString(),
      })

return NextResponse.json(
        {
          error: "Transaction failed",
          message: txError.message,
        },
        { status: 500 },
      )
    }
  } catch (error: any) {
    console.error("[v0 PAYOUT] Payout error:", error)
    return NextResponse.json(
      {
        error: "Payout failed",
        message: error.message,
      },
      { status: 500 },
    )
  }
}

// GET endpoint to check payout status
export async function GET() {
  try {
    const cookieStore = await cookies()
    const supabase = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, {
      cookies: {
        getAll() {
          return cookieStore.getAll()
        },
        setAll(cookiesToSet) {
          try {
            cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
          } catch {}
        },
      },
    })

// Get unpaid commission summary
    const { data: unpaidCommissions } = await supabase
      .from("commission_earnings")
      .select("commission_amount")
      .is("payout_id", null)
      .eq("status", "earned")

const unpaidTotal =
      unpaidCommissions?.reduce((sum, comm) => sum + Number.parseFloat(comm.commission_amount), 0) || 0

// Get recent payouts
    const { data: recentPayouts } = await supabase
      .from("commission_payouts")
      .select("*")
      .order("created_at", { ascending: false })
      .limit(10)

return NextResponse.json({
      unpaidCommissions: unpaidCommissions?.length || 0,
      unpaidTotal,
      recentPayouts: recentPayouts || [],
      destinationWallet: COMMISSION_WALLET_ADDRESS,
    })
  } catch (error: any) {
    console.error("[v0 PAYOUT] Error fetching payout status:", error)
    return NextResponse.json({ error: error.message }, { status: 500 })
  }
}
[V0_FILE]typescriptreact:file="app/admin/wallet-recovery/page.tsx" isMerged="true"
"use client"

import type React from "react"

import { useState } from "react"
import { AdminLayout } from "@/components/admin-layout"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { createClient } from "@/lib/supabase/client"
import { Eye, EyeOff, Copy, Check, Download, Key, Shield } from "lucide-react"

export default function WalletRecoveryPage() {
  const [password, setPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [privateKey, setPrivateKey] = useState("")
  const [walletAddress, setWalletAddress] = useState("")
  const [copiedKey, setCopiedKey] = useState(false)
  const [copiedAddress, setCopiedAddress] = useState(false)

const handleRecoverWallet = async (e: React.FormEvent) => {
    e.preventDefault()
    setError("")
    setLoading(true)
    setPrivateKey("")
    setWalletAddress("")

try {
      const supabase = createClient()

// Get current user
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (!user) {
        setError("Not authenticated. Please log in to the admin panel.")
        setLoading(false)
        return
      }

// Get profile with encrypted wallet
      const { data: profile, error: profileError } = await supabase
        .from("profiles")
        .select("encrypted_wallet, builtin_wallet_address, username")
        .eq("id", user.id)
        .single()

if (profileError || !profile) {
        setError("Failed to load wallet data from database.")
        setLoading(false)
        return
      }

if (!profile.encrypted_wallet) {
        setError("No encrypted wallet found for your account.")
        setLoading(false)
        return
      }

console.log("[v0] Attempting to decrypt wallet for user:", profile.username)

// Import ethers dynamically
      const ethers = await import("ethers")

// Parse and normalize the encrypted wallet
      const keystoreJson =
        typeof profile.encrypted_wallet === "string"
          ? profile.encrypted_wallet
          : JSON.stringify(profile.encrypted_wallet)

let normalizedKeystore = keystoreJson
      try {
        const parsed = JSON.parse(keystoreJson)
        // Web3.js uses "Crypto" but ethers.js expects "crypto"
        if (parsed.Crypto && !parsed.crypto) {
          parsed.crypto = parsed.Crypto
          delete parsed.Crypto
        }
        normalizedKeystore = JSON.stringify(parsed)
      } catch (parseError) {
        console.error("[v0] Error normalizing keystore:", parseError)
      }

console.log("[v0] Decrypting wallet with provided password...")

// Decrypt using the password provided
      const wallet = await ethers.Wallet.fromEncryptedJson(normalizedKeystore, password)

console.log("[v0] Wallet decrypted successfully!")

setPrivateKey(wallet.privateKey)
      setWalletAddress(wallet.address)
    } catch (err: any) {
      console.error("[v0] Recovery error:", err)
      if (err.message?.includes("password") || err.message?.includes("incorrect")) {
        setError("Incorrect password. Please enter your LINKFICRYPTO account password.")
      } else {
        setError(`Failed to decrypt wallet: ${err.message}`)
      }
    } finally {
      setLoading(false)
    }
  }

const copyPrivateKey = async () => {
    await navigator.clipboard.writeText(privateKey)
    setCopiedKey(true)
    setTimeout(() => setCopiedKey(false), 2000)
  }

const copyAddress = async () => {
    await navigator.clipboard.writeText(walletAddress)
    setCopiedAddress(true)
    setTimeout(() => setCopiedAddress(false), 2000)
  }

const downloadBackup = () => {
    const backupData = {
      walletAddress,
      privateKey,
      timestamp: new Date().toISOString(),
      note: "KEEP THIS FILE SECURE - Anyone with this private key can access your wallet!",
    }

const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: "application/json" })
    const url = URL.createObjectURL(blob)
    const a = document.createElement("a")
    a.href = url
    a.download = `linkficrypto-admin-wallet-backup-${Date.now()}.json`
    a.click()
    URL.revokeObjectURL(url)
  }

return (
    <AdminLayout>
      <div className="max-w-2xl mx-auto space-y-6">
        <div>
          <h1 className="text-3xl font-bold text-gray-900">Wallet Recovery</h1>
          <p className="text-gray-600 mt-1">Export your admin wallet's private key for commission payouts</p>
        </div>

<Card className="border-orange-200 bg-orange-50/50">
          <CardHeader>
            <CardTitle className="flex items-center gap-2 text-orange-900">
              <Shield className="w-5 h-5" />
              Security Warning
            </CardTitle>
            <CardDescription className="text-orange-700">
              Your private key provides full access to your wallet. Never share it with anyone and store it securely.
            </CardDescription>
          </CardHeader>
        </Card>

<Card>
          <CardHeader>
            <CardTitle>Decrypt Your Wallet</CardTitle>
            <CardDescription>
              Enter your LINKFICRYPTO account password to decrypt and export your wallet's private key
            </CardDescription>
          </CardHeader>
          <CardContent>
            <form onSubmit={handleRecoverWallet} className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="password">Account Password</Label>
                <div className="relative">
                  <Input
                    id="password"
                    type={showPassword ? "text" : "password"}
                    value={password}
                    onChange={(e) => setPassword(e.target.value)}
                    placeholder="Enter your LINKFICRYPTO password"
                    required
                    disabled={loading}
                  />
                  <button
                    type="button"
                    onClick={() => setShowPassword(!showPassword)}
                    className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                  >
                    {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                  </button>
                </div>
                <p className="text-xs text-muted-foreground">
                  This is the password you use to log into your admin account
                </p>
              </div>

{error && (
                <div className="p-3 bg-red-50 border border-red-200 rounded-lg text-sm text-red-700">{error}</div>
              )}

<Button type="submit" disabled={loading} className="w-full">
                {loading ? (
                  <>
                    <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white mr-2" />
                    Decrypting wallet...
                  </>
                ) : (
                  <>
                    <Key className="w-4 h-4 mr-2" />
                    Decrypt & Export Private Key
                  </>
                )}
              </Button>
            </form>
          </CardContent>
        </Card>

{privateKey && (
          <Card className="border-green-200 bg-green-50/50">
            <CardHeader>
              <CardTitle className="flex items-center gap-2 text-green-900">
                <Check className="w-5 h-5" />
                Wallet Decrypted Successfully
              </CardTitle>
              <CardDescription className="text-green-700">
                Your private key has been recovered. Store it securely!
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label>Wallet Address</Label>
                <div className="flex items-center gap-2">
                  <Input value={walletAddress} readOnly className="font-mono text-sm" />
                  <Button type="button" variant="outline" size="icon" onClick={copyAddress}>
                    {copiedAddress ? <Check className="w-4 h-4 text-green-600" /> : <Copy className="w-4 h-4" />}
                  </Button>
                </div>
              </div>

<div className="space-y-2">
                <Label>Private Key</Label>
                <div className="flex items-center gap-2">
                  <Input value={privateKey} readOnly type="password" className="font-mono text-sm" />
                  <Button type="button" variant="outline" size="icon" onClick={copyPrivateKey}>
                    {copiedKey ? <Check className="w-4 h-4 text-green-600" /> : <Copy className="w-4 h-4" />}
                  </Button>
                </div>
                <p className="text-xs text-muted-foreground">Click the copy button to copy your private key</p>
              </div>

<div className="pt-4 border-t">
                <Button onClick={downloadBackup} variant="outline" className="w-full bg-transparent">
                  <Download className="w-4 h-4 mr-2" />
                  Download Wallet Backup File
                </Button>
                <p className="text-xs text-center text-muted-foreground mt-2">
                  Save this file in a secure location (encrypted USB, password manager, etc.)
                </p>
              </div>

<div className="p-4 bg-blue-50 border border-blue-200 rounded-lg">
                <h4 className="font-semibold text-sm text-blue-900 mb-2">Next Steps:</h4>
                <ol className="text-sm text-blue-700 space-y-1 list-decimal list-inside">
                  <li>Copy your private key and store it securely</li>
                  <li>Go to the Commission Payout page</li>
                  <li>Use this private key to send commissions to your 1inch wallet</li>
                </ol>
              </div>
            </CardContent>
          </Card>
        )}
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescript:file="app/api/admin/check-balance/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { ethers } from "ethers"

export async function POST(request: Request) {
  try {
    const body = await request.json()
    const { privateKey } = body

if (!privateKey) {
      return NextResponse.json({ error: "Private key required" }, { status: 400 })
    }

// Create provider
    const provider = new ethers.JsonRpcProvider(process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL!)

// Create wallet from private key
    const wallet = new ethers.Wallet(privateKey, provider)

// Get balance
    const balance = await provider.getBalance(wallet.address)
    const balanceInEth = ethers.formatEther(balance)

return NextResponse.json({
      address: wallet.address,
      balance: balanceInEth,
      network: "Ethereum Mainnet",
    })
  } catch (error: any) {
    console.error("[v0 BALANCE CHECK] Error:", error)
    return NextResponse.json(
      {
        error: "Failed to check balance",
        message: error.message,
      },
      { status: 500 },
    )
  }
}
[V0_FILE]typescriptreact:file="app/admin/commissions/page.tsx" isMerged="true"
"use client"

import { useEffect, useState } from "react"
import { AdminLayout } from "@/components/admin-layout"
import { createClient } from "@/lib/supabase/client"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"
import {
  ArrowUpRight,
  Wallet,
  DollarSign,
  TrendingUp,
  Copy,
  Check,
  RefreshCw,
  CheckCircle,
  Clock,
  XCircle,
  ExternalLink,
  BarChart3,
  Calendar,
  ArrowDownRight,
} from "lucide-react"
import { COMMISSION_RATE, COMMISSION_WALLET_ADDRESS } from "@/lib/commission-config"

interface CommissionStats {
  wallet: {
    address: string
    shortAddress: string
    balance: string
    balanceUsd: string
    isValid: boolean
  }
  stats: {
    totalEarned: string
    totalEarnedUsd: string
    totalPaid: string
    totalPaidUsd: string
    totalPending: string
    totalPendingUsd: string
    totalFailed: string
    todayEarned: string
    todayEarnedUsd: string
    weekEarned: string
    weekEarnedUsd: string
    transactionCount: number
    paidCount: number
    pendingCount: number
    failedCount: number
  }
  rate: {
    current: number
    percent: number
  }
  ethPrice: number
  recentPayouts: any[]
  chartData: { date: string; amount: number }[]
}

interface CommissionTransaction {
  id: string
  tx_hash: string
  from_address: string
  to_address: string
  amount: string
  commission_amount: string
  token: string
  status: string
  created_at: string
  commission_tx_hash?: string
}

export default function CommissionsAdminPage() {
  const [commissions, setCommissions] = useState<CommissionTransaction[]>([])
  const [stats, setStats] = useState<CommissionStats | null>(null)
  const [loading, setLoading] = useState(true)
  const [copied, setCopied] = useState(false)
  const [isAuthenticated, setIsAuthenticated] = useState(false)
  const [activeTab, setActiveTab] = useState<"overview" | "transactions">("overview")

useEffect(() => {
    checkAuthAndLoadData()
  }, [])

const checkAuthAndLoadData = async () => {
    try {
      const supabase = createClient()

const {
        data: { session },
      } = await supabase.auth.getSession()

if (!session) {
        setIsAuthenticated(false)
        setLoading(false)
        return
      }

setIsAuthenticated(true)
      await Promise.all([loadStats(), loadCommissions()])
    } catch (error) {
      console.error("[v0] Authentication check failed:", error)
      setIsAuthenticated(false)
      setLoading(false)
    }
  }

const loadStats = async () => {
    try {
      const response = await fetch("/api/admin/commission-stats")
      if (!response.ok) throw new Error("Failed to load stats")
      const data = await response.json()
      setStats(data)
    } catch (error) {
      console.error("[v0] Error loading commission stats:", error)
    }
  }

const loadCommissions = async () => {
    try {
      setLoading(true)
      const response = await fetch("/api/admin/commissions")
      if (!response.ok) throw new Error("Failed to load commissions")
      const data = await response.json()
      setCommissions(data.commissions || [])
    } catch (error) {
      console.error("[v0] Error loading commissions:", error)
    } finally {
      setLoading(false)
    }
  }

const handleRefresh = async () => {
    setLoading(true)
    await Promise.all([loadStats(), loadCommissions()])
    setLoading(false)
  }

const formatDate = (dateString: string) => {
    return new Date(dateString).toLocaleString("en-US", {
      month: "short",
      day: "numeric",
      year: "numeric",
      hour: "2-digit",
      minute: "2-digit",
    })
  }

const formatEth = (amount: string | number) => {
    const num = typeof amount === "string" ? Number.parseFloat(amount) : amount
    return `${num.toFixed(8)} ETH`
  }

const shortenTxHash = (hash: string) => {
    if (!hash) return "N/A"
    return `${hash.slice(0, 10)}...${hash.slice(-8)}`
  }

const shortenAddress = (address: string) => {
    if (!address) return "N/A"
    return `${address.slice(0, 6)}...${address.slice(-4)}`
  }

const getStatusBadge = (status: string) => {
    switch (status) {
      case "paid":
        return (
          <span className="inline-flex items-center gap-1 text-xs px-2 py-1 rounded-full bg-green-100 text-green-700">
            <CheckCircle className="w-3 h-3" /> Paid
          </span>
        )
      case "pending":
      case "earned":
        return (
          <span className="inline-flex items-center gap-1 text-xs px-2 py-1 rounded-full bg-yellow-100 text-yellow-700">
            <Clock className="w-3 h-3" /> Pending
          </span>
        )
      case "failed":
        return (
          <span className="inline-flex items-center gap-1 text-xs px-2 py-1 rounded-full bg-red-100 text-red-700">
            <XCircle className="w-3 h-3" /> Failed
          </span>
        )
      default:
        return (
          <span className="text-xs px-2 py-1 rounded-full bg-gray-100 text-gray-700">
            {status}
          </span>
        )
    }
  }

const copyToClipboard = (text: string) => {
    navigator.clipboard.writeText(text)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

return (
    <AdminLayout>
      <div className="space-y-6">
        {/* Header */}
        <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
          <div>
            <h1 className="text-3xl font-bold text-gray-900">Commission Dashboard</h1>
            <p className="text-gray-600 mt-1">
              Track earnings and manage commission payouts ({COMMISSION_RATE * 100}% fee)
            </p>
          </div>
          <Button onClick={handleRefresh} variant="outline" size="sm" disabled={loading}>
            <RefreshCw className={`h-4 w-4 mr-2 ${loading ? "animate-spin" : ""}`} />
            Refresh
          </Button>
        </div>

{/* Wallet Status Card */}
        <Card className="border-2 border-blue-200 bg-gradient-to-r from-blue-50 to-indigo-50">
          <CardHeader className="pb-2">
            <CardTitle className="flex items-center gap-2 text-blue-900">
              <Wallet className="w-5 h-5" />
              Commission Wallet
              {stats?.wallet.isValid ? (
                <CheckCircle className="w-4 h-4 text-green-500" />
              ) : (
                <XCircle className="w-4 h-4 text-red-500" />
              )}
            </CardTitle>
            <CardDescription className="text-blue-700">
              All commissions are sent directly to this wallet
            </CardDescription>
          </CardHeader>
          <CardContent>
            <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
              <div className="space-y-1">
                <div className="flex items-center gap-2">
                  <code className="text-lg font-mono font-bold text-blue-900">
                    {stats?.wallet.shortAddress || shortenAddress(COMMISSION_WALLET_ADDRESS)}
                  </code>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="h-8 w-8 p-0"
                    onClick={() => copyToClipboard(COMMISSION_WALLET_ADDRESS)}
                  >
                    {copied ? (
                      <Check className="h-4 w-4 text-green-600" />
                    ) : (
                      <Copy className="h-4 w-4 text-blue-600" />
                    )}
                  </Button>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="h-8 w-8 p-0"
                    onClick={() =>
                      window.open(
                        `https://etherscan.io/address/${COMMISSION_WALLET_ADDRESS}`,
                        "_blank"
                      )
                    }
                  >
                    <ExternalLink className="h-4 w-4 text-blue-600" />
                  </Button>
                </div>
                <p className="text-sm text-blue-700">Your 1inch wallet for receiving commissions</p>
              </div>
              <div className="text-right">
                <div className="text-2xl font-bold text-blue-900">
                  {stats?.wallet.balance ? Number.parseFloat(stats.wallet.balance).toFixed(6) : "0.000000"} ETH
                </div>
                <p className="text-sm text-blue-700">${stats?.wallet.balanceUsd || "0.00"} USD</p>
              </div>
            </div>
          </CardContent>
        </Card>

{/* Stats Grid */}
        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
          <Card className="border-green-200 bg-gradient-to-br from-green-50 to-emerald-50">
            <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
              <CardTitle className="text-sm font-medium text-green-900">Total Earned</CardTitle>
              <TrendingUp className="h-4 w-4 text-green-600" />
            </CardHeader>
            <CardContent>
              <div className="text-2xl font-bold text-green-900">{stats?.stats.totalEarned || "0.00000000"} ETH</div>
              <p className="text-xs text-green-700">${stats?.stats.totalEarnedUsd || "0.00"} USD</p>
            </CardContent>
          </Card>

<Card className="border-blue-200 bg-gradient-to-br from-blue-50 to-cyan-50">
            <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
              <CardTitle className="text-sm font-medium text-blue-900">Paid Out</CardTitle>
              <CheckCircle className="h-4 w-4 text-blue-600" />
            </CardHeader>
            <CardContent>
              <div className="text-2xl font-bold text-blue-900">{stats?.stats.totalPaid || "0.00000000"} ETH</div>
              <p className="text-xs text-blue-700">
                {stats?.stats.paidCount || 0} transactions
              </p>
            </CardContent>
          </Card>

<Card className="border-yellow-200 bg-gradient-to-br from-yellow-50 to-amber-50">
            <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
              <CardTitle className="text-sm font-medium text-yellow-900">Pending</CardTitle>
              <Clock className="h-4 w-4 text-yellow-600" />
            </CardHeader>
            <CardContent>
              <div className="text-2xl font-bold text-yellow-900">{stats?.stats.totalPending || "0.00000000"} ETH</div>
              <p className="text-xs text-yellow-700">
                {stats?.stats.pendingCount || 0} transactions
              </p>
            </CardContent>
          </Card>

<Card className="border-purple-200 bg-gradient-to-br from-purple-50 to-fuchsia-50">
            <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
              <CardTitle className="text-sm font-medium text-purple-900">Today</CardTitle>
              <Calendar className="h-4 w-4 text-purple-600" />
            </CardHeader>
            <CardContent>
              <div className="text-2xl font-bold text-purple-900">{stats?.stats.todayEarned || "0.00000000"} ETH</div>
              <p className="text-xs text-purple-700">${stats?.stats.todayEarnedUsd || "0.00"} USD</p>
            </CardContent>
          </Card>
        </div>

{/* Weekly Chart */}
        {stats?.chartData && stats.chartData.length > 0 && (
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <BarChart3 className="w-5 h-5 text-blue-600" />
                Weekly Commission Earnings
              </CardTitle>
              <CardDescription>Commission earned over the last 7 days</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="flex items-end justify-between h-40 gap-2">
                {stats.chartData.map((day, i) => {
                  const maxAmount = Math.max(...stats.chartData.map((d) => d.amount), 0.00001)
                  const height = (day.amount / maxAmount) * 100
                  return (
                    <div key={i} className="flex-1 flex flex-col items-center gap-1">
                      <div
                        className="w-full bg-gradient-to-t from-blue-500 to-blue-400 rounded-t-sm transition-all hover:from-blue-600 hover:to-blue-500"
                        style={{ height: `${Math.max(height, 4)}%` }}
                        title={`${day.amount.toFixed(8)} ETH`}
                      />
                      <span className="text-xs text-gray-500">{day.date}</span>
                    </div>
                  )
                })}
              </div>
              <div className="mt-4 pt-4 border-t flex items-center justify-between text-sm">
                <span className="text-gray-600">This week total:</span>
                <span className="font-bold text-blue-900">
                  {stats.stats.weekEarned} ETH (${stats.stats.weekEarnedUsd})
                </span>
              </div>
            </CardContent>
          </Card>
        )}

{/* How it Works */}
        <Card className="border-green-200 bg-green-50">
          <CardHeader>
            <CardTitle className="text-green-900">How Commissions Work</CardTitle>
            <CardDescription className="text-green-700">
              Automatic commission collection for every transaction
            </CardDescription>
          </CardHeader>
          <CardContent className="space-y-3 text-sm text-green-800">
            <div className="flex items-start gap-3">
              <div className="mt-1 h-6 w-6 rounded-full bg-green-200 flex items-center justify-center flex-shrink-0">
                <span className="text-green-700 font-bold text-xs">1</span>
              </div>
              <div>
                <p className="font-semibold">User Initiates Transaction</p>
                <p className="text-green-700">When a user sends ETH or tokens, the system calculates the {(COMMISSION_RATE * 100).toFixed(1)}% platform fee.</p>
              </div>
            </div>
            <div className="flex items-start gap-3">
              <div className="mt-1 h-6 w-6 rounded-full bg-green-200 flex items-center justify-center flex-shrink-0">
                <span className="text-green-700 font-bold text-xs">2</span>
              </div>
              <div>
                <p className="font-semibold">Automatic Commission Transfer</p>
                <p className="text-green-700">The commission is sent directly to your wallet ({stats?.wallet.shortAddress || shortenAddress(COMMISSION_WALLET_ADDRESS)}) in a separate transaction.</p>
              </div>
            </div>
            <div className="flex items-start gap-3">
              <div className="mt-1 h-6 w-6 rounded-full bg-green-200 flex items-center justify-center flex-shrink-0">
                <span className="text-green-700 font-bold text-xs">3</span>
              </div>
              <div>
                <p className="font-semibold">Instant Verification</p>
                <p className="text-green-700">All commission payments are recorded with transaction hashes for verification on Etherscan.</p>
              </div>
            </div>
          </CardContent>
        </Card>

{/* Tabs */}
        <div className="flex gap-2 border-b">
          <button
            onClick={() => setActiveTab("overview")}
            className={`px-4 py-2 text-sm font-medium border-b-2 transition-colors ${
              activeTab === "overview"
                ? "border-blue-600 text-blue-600"
                : "border-transparent text-gray-600 hover:text-gray-900"
            }`}
          >
            Overview
          </button>
          <button
            onClick={() => setActiveTab("transactions")}
            className={`px-4 py-2 text-sm font-medium border-b-2 transition-colors ${
              activeTab === "transactions"
                ? "border-blue-600 text-blue-600"
                : "border-transparent text-gray-600 hover:text-gray-900"
            }`}
          >
            All Transactions ({commissions.length})
          </button>
        </div>

{/* Content based on active tab */}
        {activeTab === "overview" ? (
          <div className="grid gap-6 lg:grid-cols-2">
            {/* Recent Commission Payments */}
            <Card>
              <CardHeader>
                <CardTitle className="flex items-center gap-2">
                  <ArrowDownRight className="w-5 h-5 text-green-600" />
                  Recent Payouts
                </CardTitle>
                <CardDescription>Latest commission payouts to your wallet</CardDescription>
              </CardHeader>
              <CardContent>
                {stats?.recentPayouts && stats.recentPayouts.length > 0 ? (
                  <div className="space-y-3">
                    {stats.recentPayouts.map((payout) => (
                      <div
                        key={payout.id}
                        className="flex items-center justify-between p-3 bg-gray-50 rounded-lg"
                      >
                        <div>
                          <div className="font-semibold">
                            {Number.parseFloat(payout.payout_amount).toFixed(6)} ETH
                          </div>
                          <div className="text-xs text-gray-500">
                            {formatDate(payout.created_at)}
                          </div>
                        </div>
                        <div className="flex items-center gap-2">
                          {getStatusBadge(payout.status)}
                          {payout.tx_hash && (
                            <Button
                              variant="ghost"
                              size="sm"
                              className="h-8 w-8 p-0"
                              onClick={() =>
                                window.open(
                                  `https://etherscan.io/tx/${payout.tx_hash}`,
                                  "_blank"
                                )
                              }
                            >
                              <ExternalLink className="h-4 w-4" />
                            </Button>
                          )}
                        </div>
                      </div>
                    ))}
                  </div>
                ) : (
                  <div className="text-center py-8 text-gray-500">
                    <DollarSign className="w-12 h-12 mx-auto mb-2 opacity-50" />
                    <p>No payouts yet</p>
                  </div>
                )}
              </CardContent>
            </Card>

{/* Quick Stats */}
            <Card>
              <CardHeader>
                <CardTitle className="flex items-center gap-2">
                  <BarChart3 className="w-5 h-5 text-purple-600" />
                  Quick Stats
                </CardTitle>
                <CardDescription>Commission performance metrics</CardDescription>
              </CardHeader>
              <CardContent className="space-y-4">
                <div className="flex items-center justify-between p-3 bg-gray-50 rounded-lg">
                  <span className="text-gray-600">Commission Rate</span>
                  <span className="font-bold">{stats?.rate.percent || COMMISSION_RATE * 100}%</span>
                </div>
                <div className="flex items-center justify-between p-3 bg-gray-50 rounded-lg">
                  <span className="text-gray-600">Total Transactions</span>
                  <span className="font-bold">{stats?.stats.transactionCount || 0}</span>
                </div>
                <div className="flex items-center justify-between p-3 bg-gray-50 rounded-lg">
                  <span className="text-gray-600">ETH Price</span>
                  <span className="font-bold">${stats?.ethPrice?.toFixed(2) || "3000.00"}</span>
                </div>
                <div className="flex items-center justify-between p-3 bg-green-50 rounded-lg border border-green-200">
                  <span className="text-green-700">Success Rate</span>
                  <span className="font-bold text-green-700">
                    {stats?.stats.transactionCount
                      ? (
                          ((stats.stats.paidCount / stats.stats.transactionCount) * 100) ||
                          0
                        ).toFixed(1)
                      : "0.0"}
                    %
                  </span>
                </div>
              </CardContent>
            </Card>
          </div>
        ) : (
          /* Transactions List */
          <Card>
            <CardHeader>
              <CardTitle className="text-purple-900">Commission History</CardTitle>
              <CardDescription>All platform transactions with {COMMISSION_RATE * 100}% commission</CardDescription>
            </CardHeader>
            <CardContent>
              {loading ? (
                <div className="flex items-center justify-center py-12">
                  <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-purple-600" />
                </div>
              ) : !isAuthenticated ? (
                <div className="text-center py-12 bg-red-50 rounded-lg border-2 border-dashed border-red-300">
                  <DollarSign className="w-12 h-12 text-red-400 mx-auto mb-3" />
                  <p className="text-red-600 font-medium">Authentication Required</p>
                  <p className="text-sm text-red-500 mt-2">
                    Please refresh the page and sign in again to view commission data
                  </p>
                </div>
              ) : commissions.length === 0 ? (
                <div className="text-center py-12 bg-gray-50 rounded-lg border-2 border-dashed border-gray-300">
                  <DollarSign className="w-12 h-12 text-gray-400 mx-auto mb-3" />
                  <p className="text-gray-600 font-medium">No commission records yet</p>
                  <p className="text-sm text-gray-500 mt-2">
                    Commissions will appear here as users make transactions
                  </p>
                </div>
              ) : (
                <div className="space-y-3">
                  {commissions.map((transaction) => (
                    <div
                      key={transaction.id}
                      className="flex items-center justify-between p-4 border-2 border-gray-200 rounded-lg hover:border-purple-300 hover:shadow-sm transition-all"
                    >
                      <div className="space-y-1 flex-1">
                        <div className="flex items-center gap-3">
                          <span className="text-base font-semibold text-gray-900">
                            Commission: {formatEth(transaction.commission_amount)}
                          </span>
                          {getStatusBadge(transaction.status)}
                        </div>
                        <div className="flex items-center gap-2 text-sm text-gray-600">
                          <span>
                            Transaction: {Number.parseFloat(transaction.amount).toFixed(4)} {transaction.token || "ETH"}
                          </span>
                          <span className="text-gray-400">|</span>
                          <span className="text-xs">
                            {shortenAddress(transaction.from_address)} → {shortenAddress(transaction.to_address)}
                          </span>
                        </div>
                        <div className="flex items-center gap-2 text-xs text-gray-500">
                          <span>TX: {shortenTxHash(transaction.tx_hash)}</span>
                          {transaction.commission_tx_hash && (
                            <>
                              <span className="text-gray-400">|</span>
                              <span>Commission TX: {shortenTxHash(transaction.commission_tx_hash)}</span>
                            </>
                          )}
                        </div>
                        <p className="text-xs text-gray-500">{formatDate(transaction.created_at)}</p>
                      </div>
                      <div className="flex flex-col gap-2">
                        <Button
                          variant="outline"
                          size="sm"
                          className="border-blue-200 hover:bg-blue-50"
                          onClick={() =>
                            window.open(`https://etherscan.io/tx/${transaction.tx_hash}`, "_blank")
                          }
                        >
                          <ArrowUpRight className="h-4 w-4 mr-1" />
                          View TX
                        </Button>
                        {transaction.commission_tx_hash && (
                          <Button
                            variant="outline"
                            size="sm"
                            className="border-green-200 hover:bg-green-50"
                            onClick={() =>
                              window.open(
                                `https://etherscan.io/tx/${transaction.commission_tx_hash}`,
                                "_blank"
                              )
                            }
                          >
                            <CheckCircle className="h-4 w-4 mr-1 text-green-600" />
                            Commission TX
                          </Button>
                        )}
                      </div>
                    </div>
                  ))}
                </div>
              )}
            </CardContent>
          </Card>
        )}
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescript:file="app/api/admin/stats/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { createClient } from "@supabase/supabase-js"
import { COMMISSION_RATE } from "@/lib/commission-config"

export async function GET() {
  try {
    console.log("[v0] Stats API called")

const supabase = createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, {
      auth: {
        autoRefreshToken: false,
        persistSession: false,
      },
    })

// Get total users
    const { count: usersCount } = await supabase.from("profiles").select("*", { count: "exact", head: true })
    console.log("[v0] Users count:", usersCount)

// Get all transactions
    const { data: transactions, count: transactionsCount } = await supabase
      .from("transactions")
      .select("amount, commission_amount, created_at, status, from_address, to_address, token, tx_hash", {
        count: "exact",
      })

console.log("[v0] Transactions count:", transactionsCount)
    console.log("[v0] Transactions data length:", transactions?.length)

const totalVolume = transactions?.reduce((sum, tx) => sum + (Number.parseFloat(tx.amount) || 0), 0) || 0

// Calculate commissions: use stored commission_amount if available, otherwise calculate 1% of send transactions
    const totalCommissions = transactions?.reduce((sum, tx) => {
      // If commission_amount is stored, use it
      if (tx.commission_amount && Number.parseFloat(tx.commission_amount) > 0) {
        return sum + Number.parseFloat(tx.commission_amount)
      }
      // Otherwise calculate 1% commission on the transaction amount
      const amount = Number.parseFloat(tx.amount) || 0
      return sum + (amount * COMMISSION_RATE)
    }, 0) || 0

console.log("[v0] Total volume:", totalVolume, "Total commissions:", totalCommissions)

// Get recent transactions (last 24h)
    const yesterday = new Date()
    yesterday.setDate(yesterday.getDate() - 1)
    const { count: recentCount } = await supabase
      .from("transactions")
      .select("*", { count: "exact", head: true })
      .gte("created_at", yesterday.toISOString())

// Get recent activity
    const { data: recentTxs } = await supabase
      .from("transactions")
      .select("*")
      .order("created_at", { ascending: false })
      .limit(5)

const response = {
      totalUsers: usersCount || 0,
      totalTransactions: transactionsCount || 0,
      totalCommissions: totalCommissions.toFixed(8),
      recentTransactions: recentCount || 0,
      totalVolume: totalVolume.toFixed(6),
      avgTransactionValue: transactionsCount ? (totalVolume / transactionsCount).toFixed(6) : "0",
      recentActivity: recentTxs || [],
    }

console.log("[v0] Sending response:", response)

return NextResponse.json(response)
  } catch (error) {
    console.error("[v0] Failed to load admin stats:", error)
    return NextResponse.json({ error: "Failed to load stats" }, { status: 500 })
  }
}
[V0_FILE]typescriptreact:file="app/privacy/page.tsx" isEdit="true" isMerged="true"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { ArrowLeft } from "lucide-react"

export const metadata = {
  title: "Privacy Policy",
  description: "LinkFiCrypto Privacy Policy - Learn how we protect your data and privacy",
}

export default function PrivacyPage() {
  return (
    <div className="min-h-screen bg-background">
      <div className="container mx-auto px-4 py-8 max-w-4xl">
        <Link href="/">
          <Button variant="ghost" className="mb-6">
            <ArrowLeft className="mr-2 h-4 w-4" />
            Back to Home
          </Button>
        </Link>

<h1 className="text-4xl font-bold mb-2">Privacy Policy</h1>
        <p className="text-muted-foreground mb-8">Last updated: January 12, 2026</p>

<div className="prose prose-neutral dark:prose-invert max-w-none space-y-6">
          <section>
            <h2 className="text-2xl font-semibold mb-4">1. Introduction</h2>
            <p className="text-muted-foreground leading-relaxed">
              LinkFiCrypto ("we," "our," or "us") is committed to protecting your privacy. This Privacy Policy explains
              how we collect, use, disclose, and safeguard your information when you use our non-custodial
              cryptocurrency wallet service. As a non-custodial wallet, we do not have access to your private keys or
              funds. This policy complies with GDPR (EU), CCPA/CPRA (California), UK GDPR, Brazil's LGPD, and other
              applicable data protection laws.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">2. Information We Collect</h2>
            <h3 className="text-xl font-semibold mb-3">2.1 Information You Provide</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We collect minimal information as a non-custodial wallet:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Account credentials (username, encrypted passwords)</li>
              <li>Wallet addresses you connect to our service</li>
              <li>Transaction history visible on public blockchains</li>
              <li>Communication data if you contact our support team</li>
              <li>Optional profile information (display name, preferences)</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">2.2 Automatically Collected Information</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Device information (browser type, operating system, device identifiers)</li>
              <li>IP address and precise geolocation data (with your consent)</li>
              <li>Usage data, analytics, and behavioral patterns</li>
              <li>Cookies, web beacons, and similar tracking technologies</li>
              <li>Network information and connection metadata</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">2.3 Sensitive Data</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We do not intentionally collect sensitive personal data such as biometric information, health data, or
              financial account numbers. Your private keys and seed phrases are encrypted locally on your device and
              never transmitted to our servers.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">2.4 Automated Decision-Making and AI</h3>
            <p className="text-muted-foreground leading-relaxed">
              We may use automated systems and AI for fraud detection, security monitoring, and service optimization.
              You have the right to request human review of automated decisions that significantly affect you.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">3. How We Use Your Information</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We process your data based on the following legal bases:
            </p>

<h3 className="text-xl font-semibold mb-3">3.1 Contractual Necessity</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Provide and maintain our wallet service</li>
              <li>Process your transactions on blockchain networks</li>
              <li>Authenticate and secure your account</li>
              <li>Provide customer support</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.2 Legitimate Interests</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Improve user experience and service functionality</li>
              <li>Detect and prevent fraud, security issues, and illegal activities</li>
              <li>Conduct analytics and research to improve our services</li>
              <li>Send important service updates and notifications</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.3 Legal Compliance</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Comply with legal obligations and regulations</li>
              <li>Respond to lawful requests from authorities</li>
              <li>Enforce our terms of service and protect our rights</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.4 With Your Consent</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Marketing communications (you can opt-out anytime)</li>
              <li>Optional features that require additional data access</li>
              <li>Third-party integrations you choose to enable</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">4. Data Sharing and Disclosure</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We do not sell, rent, or trade your personal information. We may share information with:
            </p>

<h3 className="text-xl font-semibold mb-3">4.1 Service Providers</h3>
            <p className="text-muted-foreground leading-relaxed mb-2">
              We engage trusted third-party service providers who assist in operating our platform under strict
              contractual obligations:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Cloud hosting and infrastructure (Vercel, Supabase)</li>
              <li>Analytics providers (Google Analytics)</li>
              <li>Security and fraud prevention services</li>
              <li>Customer support tools</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">4.2 Blockchain Networks</h3>
            <p className="text-muted-foreground leading-relaxed">
              Transaction data is public by nature of blockchain technology. Once you submit a transaction, it becomes
              permanently visible on the public blockchain.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">4.3 Legal Requirements</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Law enforcement when required by valid legal process</li>
              <li>Regulatory authorities for compliance purposes</li>
              <li>Court orders, subpoenas, or other legal obligations</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">4.4 Business Transfers</h3>
            <p className="text-muted-foreground leading-relaxed">
              In the event of a merger, acquisition, or sale of assets, your information may be transferred to the
              successor entity. We will notify you of any such change.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">4.5 With Your Consent</h3>
            <p className="text-muted-foreground leading-relaxed">
              We will share information with third parties only with your explicit consent.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">5. Your Privacy Rights</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              Depending on your jurisdiction, you have the following rights:
            </p>

<h3 className="text-xl font-semibold mb-3">5.1 Universal Rights</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Right to Access:</strong> Obtain a copy of your personal data we hold
              </li>
              <li>
                <strong>Right to Rectification:</strong> Request correction of inaccurate data
              </li>
              <li>
                <strong>Right to Deletion ("Right to be Forgotten"):</strong> Request deletion of your data
              </li>
              <li>
                <strong>Right to Data Portability:</strong> Receive your data in a machine-readable format
              </li>
              <li>
                <strong>Right to Withdraw Consent:</strong> Withdraw consent at any time
              </li>
              <li>
                <strong>Right to Object:</strong> Object to processing based on legitimate interests
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.2 GDPR Rights (EU/EEA/UK)</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Right to Restriction:</strong> Restrict processing in certain circumstances
              </li>
              <li>
                <strong>Right to Lodge a Complaint:</strong> File a complaint with your supervisory authority
              </li>
              <li>
                <strong>Right to Human Review:</strong> Contest automated decisions
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.3 CCPA/CPRA Rights (California)</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Right to Know:</strong> Know what categories of data we collect
              </li>
              <li>
                <strong>Right to Delete:</strong> Request deletion of your data
              </li>
              <li>
                <strong>Right to Opt-Out:</strong> Opt-out of sale/sharing of data (we don't sell data)
              </li>
              <li>
                <strong>Right to Limit Use of Sensitive Data:</strong> Limit use of sensitive personal information
              </li>
              <li>
                <strong>Right to Non-Discrimination:</strong> Equal service regardless of privacy rights exercise
              </li>
              <li>
                <strong>Right to Correct:</strong> Correct inaccurate personal information
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.4 AI Transparency Rights (New 2026)</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Right to Explanation:</strong> Understand how AI systems process your data
              </li>
              <li>
                <strong>Right to Contest:</strong> Challenge automated decisions that significantly affect you
              </li>
              <li>
                <strong>Right to Human Oversight:</strong> Request human review of AI-driven decisions
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.5 Exercising Your Rights</h3>
            <p className="text-muted-foreground leading-relaxed">
              To exercise any of these rights, contact us at privacy@linkficrypto.com. We will respond within 30 days
              (45 days for complex requests). You may be required to verify your identity before we fulfill your
              request.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">6. Data Security</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We implement comprehensive security measures to protect your information:
            </p>

<h3 className="text-xl font-semibold mb-3">6.1 Technical Safeguards</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>End-to-end encryption for sensitive data</li>
              <li>TLS/SSL encryption for data in transit</li>
              <li>AES-256 encryption for data at rest</li>
              <li>Regular security audits and penetration testing</li>
              <li>Multi-factor authentication options</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">6.2 Organizational Safeguards</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Access controls and role-based permissions</li>
              <li>Employee training on data protection</li>
              <li>Regular security awareness programs</li>
              <li>Incident response and disaster recovery plans</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">6.3 Your Responsibility</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              As a non-custodial wallet, you are responsible for:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Securing your private keys and seed phrases</li>
              <li>Using strong, unique passwords</li>
              <li>Enabling two-factor authentication</li>
              <li>Keeping your device and software updated</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">6.4 Data Breach Notification</h3>
            <p className="text-muted-foreground leading-relaxed">
              In the event of a data breach that poses a risk to your rights, we will notify you and relevant
              authorities within 72 hours as required by law. We will provide information about the nature of the
              breach, potential consequences, and measures taken to address it.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">7. Data Retention</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We retain your personal data only as long as necessary for the purposes stated in this policy:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Account Data:</strong> Retained while your account is active and for 90 days after deletion
                request
              </li>
              <li>
                <strong>Transaction Records:</strong> 7 years for regulatory compliance
              </li>
              <li>
                <strong>Support Communications:</strong> 3 years from last interaction
              </li>
              <li>
                <strong>Analytics Data:</strong> Aggregated and anonymized after 26 months
              </li>
              <li>
                <strong>Security Logs:</strong> 1 year for incident investigation
              </li>
            </ul>
            <p className="text-muted-foreground leading-relaxed mt-4">
              After retention periods expire, we securely delete or anonymize your data. Blockchain transaction data is
              permanently public and cannot be deleted.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">8. International Data Transfers</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              Your information may be transferred to and processed in countries other than your country of residence,
              including the United States. We ensure appropriate safeguards are in place:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>EU-US Data Privacy Framework:</strong> For transfers to the US
              </li>
              <li>
                <strong>Standard Contractual Clauses (SCCs):</strong> EU-approved transfer mechanisms
              </li>
              <li>
                <strong>UK International Data Transfer Agreement (IDTA):</strong> For UK data transfers
              </li>
              <li>
                <strong>Adequacy Decisions:</strong> Transfers to countries deemed adequate by relevant authorities
              </li>
              <li>
                <strong>Binding Corporate Rules:</strong> Internal data transfer policies
              </li>
            </ul>
            <p className="text-muted-foreground leading-relaxed mt-4">
              You can request a copy of the safeguards we use for international transfers by contacting us.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">9. Children's Privacy</h2>
            <p className="text-muted-foreground leading-relaxed">
              Our service is not intended for users under 18 years of age (or the age of majority in your jurisdiction).
              We do not knowingly collect information from children under 18. If we become aware that we have collected
              data from a child, we will delete it promptly. Parents or guardians who believe we may have collected
              information from a child should contact us immediately.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">10. California Privacy Rights</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              California residents have specific rights under CCPA/CPRA:
            </p>

<h3 className="text-xl font-semibold mb-3">10.1 Categories of Personal Information</h3>
            <p className="text-muted-foreground leading-relaxed mb-2">
              We collect the following categories of personal information:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Identifiers (username, email, wallet addresses)</li>
              <li>Internet/network activity (browsing history, device information)</li>
              <li>Geolocation data (with consent)</li>
              <li>Commercial information (transaction history)</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">10.2 Do Not Sell or Share</h3>
            <p className="text-muted-foreground leading-relaxed">
              We do not sell or share your personal information as defined by CCPA. We do not have actual knowledge of
              selling or sharing personal information of minors under 16 years of age.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">10.3 Shine the Light</h3>
            <p className="text-muted-foreground leading-relaxed">
              California residents can request information about personal data disclosed to third parties for direct
              marketing purposes. We do not share information for such purposes.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">11. EU/UK Representative</h2>
            <p className="text-muted-foreground leading-relaxed">
              For GDPR compliance matters, EU/EEA and UK residents can contact our designated representative at:
              gdpr@linkficrypto.com
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">12. Changes to This Policy</h2>
            <p className="text-muted-foreground leading-relaxed">
              We may update this Privacy Policy periodically to reflect changes in our practices, technology, legal
              requirements, or other factors. We will notify you of material changes by:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2 mt-4">
              <li>Posting a prominent notice on our website</li>
              <li>Sending you an email notification (if you have provided your email)</li>
              <li>Requiring you to acknowledge changes upon login</li>
            </ul>
            <p className="text-muted-foreground leading-relaxed mt-4">
              Your continued use of the Service after changes become effective constitutes acceptance of the updated
              policy.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">13. Contact Us</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              If you have questions about this Privacy Policy, wish to exercise your privacy rights, or need to report a
              concern:
            </p>
            <div className="bg-muted p-4 rounded-lg space-y-2">
              <p className="font-semibold">LinkFiCrypto Privacy Team</p>
              <p>Email: privacy@linkficrypto.com</p>
              <p>GDPR/EU Inquiries: gdpr@linkficrypto.com</p>
              <p>Data Protection Officer: dpo@linkficrypto.com</p>
            </div>
            <p className="text-muted-foreground leading-relaxed mt-4">
              We will respond to your request within 30 days (or as required by applicable law).
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">14. Supervisory Authorities</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              If you believe we have not adequately addressed your privacy concerns, you have the right to lodge a
              complaint with your local data protection authority:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>EU/EEA:</strong> Your national data protection authority
              </li>
              <li>
                <strong>UK:</strong> Information Commissioner's Office (ICO)
              </li>
              <li>
                <strong>California:</strong> California Privacy Protection Agency
              </li>
              <li>
                <strong>Brazil:</strong> Autoridade Nacional de Proteção de Dados (ANPD)
              </li>
            </ul>
          </section>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/cookies/page.tsx" isEdit="true" isMerged="true"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { ArrowLeft } from "lucide-react"

export const metadata = {
  title: "Cookie Policy",
  description: "LinkFiCrypto Cookie Policy - Learn about our use of cookies and tracking technologies",
}

export default function CookiesPage() {
  return (
    <div className="min-h-screen bg-background">
      <div className="container mx-auto px-4 py-8 max-w-4xl">
        <Link href="/">
          <Button variant="ghost" className="mb-6">
            <ArrowLeft className="mr-2 h-4 w-4" />
            Back to Home
          </Button>
        </Link>

<h1 className="text-4xl font-bold mb-2">Cookie Policy</h1>
        <p className="text-muted-foreground mb-8">Last updated: January 12, 2026</p>

<div className="prose prose-neutral dark:prose-invert max-w-none space-y-6">
          <section>
            <h2 className="text-2xl font-semibold mb-4">1. What Are Cookies</h2>
            <p className="text-muted-foreground leading-relaxed">
              Cookies are small text files stored on your device when you visit our website. They help us provide a
              better user experience by remembering your preferences and analyzing how you use our Service. This policy
              complies with the EU ePrivacy Directive, GDPR, CCPA/CPRA, and other applicable privacy regulations.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">2. Types of Cookies We Use</h2>

<h3 className="text-xl font-semibold mb-3">2.1 Strictly Necessary Cookies</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              These cookies are essential for the Service to function properly and cannot be disabled:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Session Management:</strong> Maintains your login session (session cookie)
              </li>
              <li>
                <strong>Authentication:</strong> Verifies your identity and prevents unauthorized access
              </li>
              <li>
                <strong>Security:</strong> CSRF tokens and fraud prevention (expires after 24 hours)
              </li>
              <li>
                <strong>Load Balancing:</strong> Distributes server load for performance (session cookie)
              </li>
              <li>
                <strong>Cookie Consent:</strong> Remembers your cookie preferences (1 year)
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">2.2 Performance and Analytics Cookies</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We use analytics cookies to understand how users interact with our Service (requires consent):
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Google Analytics (_ga, _gid):</strong> Usage statistics and visitor trends (2 years / 24 hours)
              </li>
              <li>
                <strong>Vercel Analytics:</strong> Performance monitoring and page load times (1 year)
              </li>
              <li>
                <strong>Heatmaps:</strong> User interaction patterns (90 days)
              </li>
              <li>
                <strong>A/B Testing:</strong> Feature optimization testing (30 days)
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">2.3 Functional Cookies</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              These cookies enhance functionality and personalization (requires consent):
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Language Preferences:</strong> Remembers your language selection (1 year)
              </li>
              <li>
                <strong>Theme Settings:</strong> Dark/light mode preferences (1 year)
              </li>
              <li>
                <strong>Wallet Connection History:</strong> Recently connected wallets (90 days)
              </li>
              <li>
                <strong>UI Preferences:</strong> Customized dashboard layouts (6 months)
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">2.4 Advertising and Marketing Cookies</h3>
            <p className="text-muted-foreground leading-relaxed">
              We do not currently use advertising cookies or third-party advertising networks. If we implement marketing
              cookies in the future, we will update this policy and obtain your explicit consent.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">2.5 Social Media Cookies</h3>
            <p className="text-muted-foreground leading-relaxed">
              If you share content via social media buttons, those platforms may set their own cookies. We do not
              control these third-party cookies.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">3. Third-Party Cookies and Services</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              We use services from trusted third parties that may set their own cookies:
            </p>

<h3 className="text-xl font-semibold mb-3">3.1 Analytics Providers</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Google Analytics:</strong> Website analytics and user behavior tracking
              </li>
              <li>
                <strong>Vercel Analytics:</strong> Performance monitoring and real-time metrics
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.2 Blockchain and Wallet Providers</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>MetaMask:</strong> Wallet connection and transaction signing
              </li>
              <li>
                <strong>WalletConnect:</strong> Multi-wallet integration protocol
              </li>
              <li>
                <strong>Coinbase Wallet:</strong> Wallet connection services
              </li>
              <li>
                <strong>Ethereum RPC Providers:</strong> Blockchain data retrieval
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.3 Security Services</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Cloudflare:</strong> DDoS protection and security monitoring
              </li>
              <li>
                <strong>reCAPTCHA:</strong> Bot detection and spam prevention
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">3.4 Third-Party Privacy Policies</h3>
            <p className="text-muted-foreground leading-relaxed mb-2">
              These third parties have their own privacy policies:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Google Privacy Policy: https://policies.google.com/privacy</li>
              <li>Vercel Privacy Policy: https://vercel.com/legal/privacy-policy</li>
              <li>MetaMask Privacy Policy: https://consensys.io/privacy-policy</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">4. Local Storage and Session Storage</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              In addition to cookies, we use browser storage technologies:
            </p>

<h3 className="text-xl font-semibold mb-3">4.1 LocalStorage</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Wallet Connection History:</strong> Previously connected wallet addresses
              </li>
              <li>
                <strong>User Preferences:</strong> Theme, language, and display settings
              </li>
              <li>
                <strong>Session Persistence:</strong> Maintains login state across browser sessions
              </li>
              <li>
                <strong>Cache Data:</strong> Improves app performance and load times
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">4.2 SessionStorage</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Temporary Data:</strong> Data for the current browsing session only
              </li>
              <li>
                <strong>Form State:</strong> Preserves form inputs during navigation
              </li>
              <li>
                <strong>Transaction Context:</strong> Temporary transaction preparation data
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">4.3 IndexedDB</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Wallet Providers:</strong> May be used by connected wallet extensions
              </li>
              <li>
                <strong>Encrypted Data:</strong> Stores encrypted wallet data locally
              </li>
              <li>
                <strong>Large Data Sets:</strong> Caches blockchain data for offline access
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">4.4 Security Considerations</h3>
            <p className="text-muted-foreground leading-relaxed">
              All sensitive data stored locally is encrypted. Your private keys are never stored in browser storage
              accessible to our application. You are responsible for keeping your device secure.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">5. Managing Cookies and Tracking</h2>

<h3 className="text-xl font-semibold mb-3">5.1 Cookie Consent Manager</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              When you first visit our site, you can choose which types of cookies to accept through our cookie consent
              banner. You can change your preferences at any time by clicking the "Cookie Settings" link in the footer.
            </p>

<h3 className="text-xl font-semibold mb-3">5.2 Browser Settings</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              Most browsers allow you to refuse or delete cookies:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Chrome:</strong> Settings → Privacy and security → Cookies and other site data
              </li>
              <li>
                <strong>Firefox:</strong> Settings → Privacy & Security → Cookies and Site Data
              </li>
              <li>
                <strong>Safari:</strong> Preferences → Privacy → Cookies and website data
              </li>
              <li>
                <strong>Edge:</strong> Settings → Cookies and site permissions → Cookies and site data
              </li>
              <li>
                <strong>Brave:</strong> Settings → Shields → Cookies and other site data
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.3 Opt-Out Tools</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Google Analytics Opt-out:</strong> https://tools.google.com/dlpage/gaoptout
              </li>
              <li>
                <strong>Do Not Track (DNT):</strong> Browser setting respected by our site
              </li>
              <li>
                <strong>Global Privacy Control (GPC):</strong> Automated privacy preferences signal
              </li>
              <li>
                <strong>Network Advertising Initiative:</strong> https://optout.networkadvertising.org/
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.4 Mobile Device Settings</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>iOS:</strong> Settings → Safari → Privacy & Security → Block All Cookies
              </li>
              <li>
                <strong>Android:</strong> Browser Settings → Site Settings → Cookies
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">5.5 Clearing Storage Data</h3>
            <p className="text-muted-foreground leading-relaxed mb-4">
              To clear LocalStorage, SessionStorage, and IndexedDB:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Open your browser's Developer Tools (F12)</li>
              <li>Navigate to the Application/Storage tab</li>
              <li>Select the storage type and click "Clear" or "Delete"</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">6. Impact of Disabling Cookies</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">Disabling cookies may affect your experience:</p>

<h3 className="text-xl font-semibold mb-3">6.1 Essential Functions</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Unable to stay logged in between sessions</li>
              <li>Security features may not function properly</li>
              <li>Form submissions may fail</li>
              <li>Service availability may be limited</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">6.2 User Experience</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>Preferences (theme, language) not saved</li>
              <li>Wallet connection history not maintained</li>
              <li>Slower page load times due to lack of caching</li>
              <li>Repetitive cookie consent prompts</li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">6.3 Analytics and Improvements</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>We cannot understand how users interact with our service</li>
              <li>Service improvements may be less targeted</li>
              <li>Bug detection and fixing may take longer</li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">7. Cookie Retention Periods</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">Different cookies have different lifespans:</p>

<h3 className="text-xl font-semibold mb-3">7.1 Session Cookies</h3>
            <p className="text-muted-foreground leading-relaxed">
              Automatically deleted when you close your browser. Used for temporary session management and security.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">7.2 Persistent Cookies</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Authentication:</strong> 30 days (automatic logout for security)
              </li>
              <li>
                <strong>Preferences:</strong> 1 year (theme, language settings)
              </li>
              <li>
                <strong>Analytics:</strong> 2 years (Google Analytics standard)
              </li>
              <li>
                <strong>Consent:</strong> 1 year (remember cookie choices)
              </li>
              <li>
                <strong>Security:</strong> 24 hours (fraud detection)
              </li>
            </ul>

<h3 className="text-xl font-semibold mb-3 mt-6">7.3 Automatic Deletion</h3>
            <p className="text-muted-foreground leading-relaxed">
              Cookies are automatically deleted when their retention period expires or when you manually clear them
              through your browser settings.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">8. Your Consent</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              By using our Service, you consent to our use of strictly necessary cookies. For all other cookies:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>First Visit:</strong> Cookie banner displays all cookie categories
              </li>
              <li>
                <strong>Granular Control:</strong> Accept all, reject all, or customize by category
              </li>
              <li>
                <strong>Withdraw Consent:</strong> Change preferences anytime via footer link
              </li>
              <li>
                <strong>Clear Communication:</strong> Plain language explanation of each cookie type
              </li>
              <li>
                <strong>Pre-Checked Boxes:</strong> No pre-selected non-essential cookies (GDPR compliant)
              </li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">9. Other Tracking Technologies</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">In addition to cookies, we may use:</p>

<h3 className="text-xl font-semibold mb-3">9.1 Web Beacons (Pixels)</h3>
            <p className="text-muted-foreground leading-relaxed">
              Small transparent images embedded in web pages or emails to track user activity and email opens.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">9.2 Fingerprinting</h3>
            <p className="text-muted-foreground leading-relaxed">
              We do not use device fingerprinting for tracking purposes. Any fingerprinting is limited to fraud
              prevention and security.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">9.3 ETags</h3>
            <p className="text-muted-foreground leading-relaxed">
              HTTP caching mechanism that may incidentally function as a tracking mechanism. We do not use ETags for
              tracking.
            </p>

<h3 className="text-xl font-semibold mb-3 mt-6">9.4 JavaScript and APIs</h3>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2">
              <li>
                <strong>Web3 APIs:</strong> Interact with blockchain wallets
              </li>
              <li>
                <strong>Browser APIs:</strong> Access device features with your permission
              </li>
              <li>
                <strong>Geolocation API:</strong> Only with explicit user consent
              </li>
            </ul>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">10. Updates to This Policy</h2>
            <p className="text-muted-foreground leading-relaxed">
              We may update this Cookie Policy to reflect changes in our practices, technology, or legal requirements.
              Material changes will be communicated through:
            </p>
            <ul className="list-disc pl-6 text-muted-foreground space-y-2 mt-4">
              <li>Updated "Last updated" date at the top of this page</li>
              <li>Cookie consent banner on your next visit</li>
              <li>Email notification for significant changes (if applicable)</li>
            </ul>
            <p className="text-muted-foreground leading-relaxed mt-4">
              We recommend reviewing this policy periodically to stay informed about our cookie practices.
            </p>
          </section>

<section>
            <h2 className="text-2xl font-semibold mb-4">11. Contact Us</h2>
            <p className="text-muted-foreground leading-relaxed mb-4">
              If you have questions about our use of cookies or this Cookie Policy:
            </p>
            <div className="bg-muted p-4 rounded-lg space-y-2">
              <p className="font-semibold">LinkFiCrypto Privacy Team</p>
              <p>Email: privacy@linkficrypto.com</p>
              <p>Cookie Inquiries: cookies@linkficrypto.com</p>
              <p>Data Protection Officer: dpo@linkficrypto.com</p>
            </div>
          </section>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/error.tsx" isMerged="true"
"use client"

import { useEffect } from "react"
import { Button } from "@/components/ui/button"
import { AlertTriangle, RefreshCw, Home } from "lucide-react"

export default function Error({
  error,
  reset,
}: {
  error: Error & { digest?: string }
  reset: () => void
}) {
  useEffect(() => {
    // Log the error to console for debugging
    console.error("[v0] Application error:", error)
  }, [error])

return (
    <div className="min-h-screen bg-background flex items-center justify-center p-4">
      <div className="max-w-md w-full bg-card rounded-2xl shadow-lg p-8 text-center">
        <div className="w-16 h-16 bg-red-100 rounded-full flex items-center justify-center mx-auto mb-6">
          <AlertTriangle className="w-8 h-8 text-red-600" />
        </div>
        
        <h1 className="text-2xl font-bold text-foreground mb-2">
          Something went wrong
        </h1>
        
        <p className="text-muted-foreground mb-6">
          We encountered an unexpected error. This could be due to a temporary network issue or a problem with your session.
        </p>

<div className="space-y-3">
          <Button 
            onClick={reset}
            className="w-full bg-primary text-primary-foreground hover:bg-primary/90"
          >
            <RefreshCw className="w-4 h-4 mr-2" />
            Try Again
          </Button>
          
          <Button 
            variant="outline"
            onClick={() => {
              // Clear potentially corrupted session data
              if (typeof window !== "undefined") {
                try {
                  sessionStorage.removeItem("linkficrypto_wallet_session")
                  sessionStorage.removeItem("unlockedWallet")
                  localStorage.removeItem("wallet_history")
                } catch (e) {
                  // Ignore storage errors
                }
              }
              window.location.href = "/"
            }}
            className="w-full"
          >
            <Home className="w-4 h-4 mr-2" />
            Clear Session & Restart
          </Button>
        </div>

{error.digest && (
          <p className="text-xs text-muted-foreground mt-4">
            Error ID: {error.digest}
          </p>
        )}
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/global-error.tsx" isMerged="true"
"use client"

import { useEffect } from "react"

export default function GlobalError({
  error,
  reset,
}: {
  error: Error & { digest?: string }
  reset: () => void
}) {
  useEffect(() => {
    console.error("[v0] Global error:", error)
  }, [error])

return (
    <html>
      <body>
        <div style={{
          minHeight: "100vh",
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          padding: "1rem",
          fontFamily: "system-ui, -apple-system, sans-serif",
          background: "#f5f5f5"
        }}>
          <div style={{
            maxWidth: "400px",
            width: "100%",
            background: "white",
            borderRadius: "1rem",
            padding: "2rem",
            textAlign: "center",
            boxShadow: "0 4px 6px rgba(0,0,0,0.1)"
          }}>
            <div style={{
              width: "64px",
              height: "64px",
              background: "#fee2e2",
              borderRadius: "50%",
              display: "flex",
              alignItems: "center",
              justifyContent: "center",
              margin: "0 auto 1.5rem"
            }}>
              <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="#dc2626" strokeWidth="2">
                <path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/>
                <line x1="12" y1="9" x2="12" y2="13"/>
                <line x1="12" y1="17" x2="12.01" y2="17"/>
              </svg>
            </div>
            
            <h1 style={{ fontSize: "1.5rem", fontWeight: "bold", marginBottom: "0.5rem", color: "#111" }}>
              Critical Error
            </h1>
            
            <p style={{ color: "#666", marginBottom: "1.5rem" }}>
              LinkFiCrypto encountered a critical error. Please try refreshing the page.
            </p>

<button 
              onClick={reset}
              style={{
                width: "100%",
                padding: "0.75rem 1rem",
                background: "#000",
                color: "white",
                border: "none",
                borderRadius: "0.5rem",
                fontSize: "1rem",
                fontWeight: "500",
                cursor: "pointer",
                marginBottom: "0.75rem"
              }}
            >
              Try Again
            </button>
            
            <button 
              onClick={() => {
                try {
                  sessionStorage.clear()
                  localStorage.removeItem("wallet_history")
                } catch (e) {}
                window.location.href = "/"
              }}
              style={{
                width: "100%",
                padding: "0.75rem 1rem",
                background: "white",
                color: "#333",
                border: "1px solid #ddd",
                borderRadius: "0.5rem",
                fontSize: "1rem",
                fontWeight: "500",
                cursor: "pointer"
              }}
            >
              Clear Cache & Restart
            </button>

{error.digest && (
              <p style={{ fontSize: "0.75rem", color: "#999", marginTop: "1rem" }}>
                Error ID: {error.digest}
              </p>
            )}
          </div>
        </div>
      </body>
    </html>
  )
}
[V0_FILE]typescriptreact:file="components/crypto-ticker.tsx" isMerged="true"
"use client"

import { useState, useEffect, useRef } from "react"
import { TrendingUp, TrendingDown } from "lucide-react"

interface CryptoPrice {
  id: string
  symbol: string
  name: string
  current_price: number
  price_change_percentage_24h: number
  image: string
}

const FALLBACK_COINS: CryptoPrice[] = [
  {
    id: "bitcoin",
    symbol: "btc",
    name: "Bitcoin",
    current_price: 96432.15,
    price_change_percentage_24h: 2.5,
    image: "https://assets.coingecko.com/coins/images/1/large/bitcoin.png",
  },
  {
    id: "ethereum",
    symbol: "eth",
    name: "Ethereum",
    current_price: 2745.82,
    price_change_percentage_24h: 1.2,
    image: "https://assets.coingecko.com/coins/images/279/large/ethereum.png",
  },
  {
    id: "solana",
    symbol: "sol",
    name: "Solana",
    current_price: 154.23,
    price_change_percentage_24h: -0.8,
    image: "https://assets.coingecko.com/coins/images/4128/large/Avalanche_Circle_RedWhite_Trans.png",
  },
  {
    id: "binancecoin",
    symbol: "bnb",
    name: "BNB",
    current_price: 612.45,
    price_change_percentage_24h: 0.5,
    image: "https://assets.coingecko.com/coins/images/825/large/binance-coin-logo.png",
  },
  {
    id: "ripple",
    symbol: "xrp",
    name: "XRP",
    current_price: 2.45,
    price_change_percentage_24h: 5.1,
    image: "https://assets.coingecko.com/coins/images/44/large/xrp-symbol-white-128.png",
  },
  {
    id: "cardano",
    symbol: "ada",
    name: "Cardano",
    current_price: 0.85,
    price_change_percentage_24h: -1.5,
    image: "https://assets.coingecko.com/coins/images/975/large/cardano.png",
  },
  {
    id: "avalanche-2",
    symbol: "avax",
    name: "Avalanche",
    current_price: 32.15,
    price_change_percentage_24h: 3.2,
    image: "https://assets.coingecko.com/coins/images/12559/large/Avalanche_Circle_RedWhite_Trans.png",
  },
  {
    id: "dogecoin",
    symbol: "doge",
    name: "Dogecoin",
    current_price: 0.32,
    price_change_percentage_24h: 8.4,
    image: "https://assets.coingecko.com/coins/images/5/large/dogecoin.png",
  },
  {
    id: "polkadot",
    symbol: "dot",
    name: "Polkadot",
    current_price: 6.54,
    price_change_percentage_24h: -0.5,
    image: "https://assets.coingecko.com/coins/images/12171/large/polkadot.png",
  },
  {
    id: "chainlink",
    symbol: "link",
    name: "Chainlink",
    current_price: 18.23,
    price_change_percentage_24h: 1.8,
    image: "https://assets.coingecko.com/coins/images/877/large/chainlink-new-logo.png",
  },
  {
    id: "shiba-inu",
    symbol: "shib",
    name: "Shiba Inu",
    current_price: 0.00002456,
    price_change_percentage_24h: 4.2,
    image: "https://assets.coingecko.com/coins/images/11939/large/shiba.png",
  },
  {
    id: "litecoin",
    symbol: "ltc",
    name: "Litecoin",
    current_price: 85.43,
    price_change_percentage_24h: 0.9,
    image: "https://assets.coingecko.com/coins/images/2/large/litecoin.png",
  },
]

export function CryptoTicker() {
  const [prices, setPrices] = useState<CryptoPrice[]>(FALLBACK_COINS)
  const [loading, setLoading] = useState(false)
  const scrollRef = useRef<HTMLDivElement>(null)

useEffect(() => {
    const fetchPrices = async () => {
      try {
        const controller = new AbortController()
        const timeoutId = setTimeout(() => controller.abort(), 5000)

const response = await fetch(
          "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=50&page=1&sparkline=false&price_change_percentage=24h",
          { signal: controller.signal },
        )

clearTimeout(timeoutId)

if (!response.ok) {
          throw new Error("Network response was not ok")
        }

const data = await response.json()

if (Array.isArray(data) && data.length > 0) {
          setPrices(data)
        }
        setLoading(false)
      } catch (error) {
        setLoading(false)
      }
    }

fetchPrices()
    const interval = setInterval(fetchPrices, 60000)
    return () => clearInterval(interval)
  }, [])

useEffect(() => {
    const element = scrollRef.current
    if (!element) return

let animationFrameId: number
    let scrollPosition = 0
    const scrollSpeed = 0.5 // pixels per frame

const animate = () => {
      scrollPosition += scrollSpeed

const maxScroll = element.scrollWidth / 3
      if (scrollPosition >= maxScroll) {
        scrollPosition = 0
      }

element.style.transform = `translateX(-${scrollPosition}px)`
      animationFrameId = requestAnimationFrame(animate)
    }

animate()

return () => {
      if (animationFrameId) {
        cancelAnimationFrame(animationFrameId)
      }
    }
  }, [prices])

if (loading) {
    return (
      <div className="bg-gradient-to-r from-primary/10 to-primary/5 border-y border-primary/20 py-3">
        <div className="container mx-auto px-4">
          <div className="flex items-center justify-center gap-2 text-sm text-muted-foreground">
            <div className="w-4 h-4 border-2 border-primary border-t-transparent rounded-full animate-spin"></div>
            Loading market prices...
          </div>
        </div>
      </div>
    )
  }

if (prices.length === 0) {
    return null
  }

let baseList = [...prices]
  while (baseList.length < 20) {
    baseList = [...baseList, ...prices]
  }

const duplicatedPrices = [...baseList, ...baseList, ...baseList]

return (
    <div className="bg-gradient-to-r from-black via-gray-900 to-black border-y border-white/10 overflow-hidden relative h-[60px] md:h-[70px]">
      <div className="absolute left-0 top-0 bottom-0 w-12 md:w-24 bg-gradient-to-r from-background to-transparent z-10 pointer-events-none"></div>
      <div className="absolute right-0 top-0 bottom-0 w-12 md:w-24 bg-gradient-to-l from-background to-transparent z-10 pointer-events-none"></div>

<div ref={scrollRef} className="flex py-4 md:py-5 items-center h-full w-max">
        {duplicatedPrices.map((coin, index) => {
          const priceChange = coin.price_change_percentage_24h ?? 0
          const currentPrice = coin.current_price ?? 0
          const isPositive = priceChange > 0
          const isNeutral = priceChange === 0

return (
            <div
              key={`${coin.id}-${index}`}
              className="flex items-center gap-2.5 md:gap-3 px-5 md:px-6 flex-shrink-0 border-r border-white/10 last:border-r-0 whitespace-nowrap"
            >
              <img
                src={coin.image || "/placeholder.svg"}
                alt={coin.name}
                className="w-6 h-6 md:w-7 md:h-7 rounded-full flex-shrink-0"
                onError={(e) => {
                  ;(e.target as HTMLImageElement).src = "/placeholder.svg?height=28&width=28"
                }}
              />
              <span className="font-bold text-sm md:text-base uppercase text-white">{coin.symbol}</span>
              <span className="text-sm md:text-base font-semibold text-white">
                $
                {currentPrice.toLocaleString("en-US", {
                  minimumFractionDigits: 2,
                  maximumFractionDigits: currentPrice < 1 ? 6 : 2,
                })}
              </span>
              <span
                className={`flex items-center gap-1 text-xs md:text-sm font-bold ${
                  isPositive ? "text-green-400" : isNeutral ? "text-gray-400" : "text-red-400"
                }`}
              >
                {isPositive ? (
                  <>
                    <TrendingUp className="w-3.5 h-3.5 md:w-4 md:h-4" />+{priceChange.toFixed(2)}%
                  </>
                ) : isNeutral ? (
                  <>0.00%</>
                ) : (
                  <>
                    <TrendingDown className="w-3.5 h-3.5 md:w-4 md:h-4" />
                    {priceChange.toFixed(2)}%
                  </>
                )}
              </span>
            </div>
          )
        })}
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/ui/chart.tsx" isMerged="true"
'use client'

import * as React from 'react'
import * as RechartsPrimitive from 'recharts'

import { cn } from '@/lib/utils'

// Format: { THEME_NAME: CSS_SELECTOR }
const THEMES = { light: '', dark: '.dark' } as const

export type ChartConfig = {
  [k in string]: {
    label?: React.ReactNode
    icon?: React.ComponentType
  } & (
    | { color?: string; theme?: never }
    | { color?: never; theme: Record<keyof typeof THEMES, string> }
  )
}

type ChartContextProps = {
  config: ChartConfig
}

const ChartContext = React.createContext<ChartContextProps | null>(null)

function useChart() {
  const context = React.useContext(ChartContext)

if (!context) {
    throw new Error('useChart must be used within a <ChartContainer />')
  }

return context
}

function ChartContainer({
  id,
  className,
  children,
  config,
  ...props
}: React.ComponentProps<'div'> & {
  config: ChartConfig
  children: React.ComponentProps<
    typeof RechartsPrimitive.ResponsiveContainer
  >['children']
}) {
  const uniqueId = React.useId()
  const chartId = `chart-${id || uniqueId.replace(/:/g, '')}`

return (
    <ChartContext.Provider value={{ config }}>
      <div
        data-slot="chart"
        data-chart={chartId}
        className={cn(
          "[&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border flex aspect-video justify-center text-xs [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden",
          className,
        )}
        {...props}
      >
        <ChartStyle id={chartId} config={config} />
        <RechartsPrimitive.ResponsiveContainer>
          {children}
        </RechartsPrimitive.ResponsiveContainer>
      </div>
    </ChartContext.Provider>
  )
}

const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
  const colorConfig = Object.entries(config).filter(
    ([, config]) => config.theme || config.color,
  )

// Use useEffect to inject styles to avoid SSR/CSR script tag warnings
  React.useEffect(() => {
    if (!colorConfig.length) return

const styleId = `chart-style-${id}`
    let styleElement = document.getElementById(styleId) as HTMLStyleElement | null
    
    if (!styleElement) {
      styleElement = document.createElement('style')
      styleElement.id = styleId
      document.head.appendChild(styleElement)
    }

const cssText = Object.entries(THEMES)
      .map(
        ([theme, prefix]) => `
${prefix} [data-chart=${id}] {
${colorConfig
  .map(([key, itemConfig]) => {
    const color =
      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
      itemConfig.color
    return color ? `  --color-${key}: ${color};` : null
  })
  .filter(Boolean)
  .join('\n')}
}
`,
      )
      .join('\n')

styleElement.textContent = cssText

return () => {
      const el = document.getElementById(styleId)
      if (el) el.remove()
    }
  }, [id, colorConfig])

return null
}

const ChartTooltip = RechartsPrimitive.Tooltip

function ChartTooltipContent({
  active,
  payload,
  className,
  indicator = 'dot',
  hideLabel = false,
  hideIndicator = false,
  label,
  labelFormatter,
  labelClassName,
  formatter,
  color,
  nameKey,
  labelKey,
}: React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
  React.ComponentProps<'div'> & {
    hideLabel?: boolean
    hideIndicator?: boolean
    indicator?: 'line' | 'dot' | 'dashed'
    nameKey?: string
    labelKey?: string
  }) {
  const { config } = useChart()

const tooltipLabel = React.useMemo(() => {
    if (hideLabel || !payload?.length) {
      return null
    }

const [item] = payload
    const key = `${labelKey || item?.dataKey || item?.name || 'value'}`
    const itemConfig = getPayloadConfigFromPayload(config, item, key)
    const value =
      !labelKey && typeof label === 'string'
        ? config[label as keyof typeof config]?.label || label
        : itemConfig?.label

if (labelFormatter) {
      return (
        <div className={cn('font-medium', labelClassName)}>
          {labelFormatter(value, payload)}
        </div>
      )
    }

if (!value) {
      return null
    }

return <div className={cn('font-medium', labelClassName)}>{value}</div>
  }, [
    label,
    labelFormatter,
    payload,
    hideLabel,
    labelClassName,
    config,
    labelKey,
  ])

if (!active || !payload?.length) {
    return null
  }

const nestLabel = payload.length === 1 && indicator !== 'dot'

return (
    <div
      className={cn(
        'border-border/50 bg-background grid min-w-[8rem] items-start gap-1.5 rounded-lg border px-2.5 py-1.5 text-xs shadow-xl',
        className,
      )}
    >
      {!nestLabel ? tooltipLabel : null}
      <div className="grid gap-1.5">
        {payload.map((item, index) => {
          const key = `${nameKey || item.name || item.dataKey || 'value'}`
          const itemConfig = getPayloadConfigFromPayload(config, item, key)
          const indicatorColor = color || item.payload.fill || item.color

return (
            <div
              key={item.dataKey}
              className={cn(
                '[&>svg]:text-muted-foreground flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5',
                indicator === 'dot' && 'items-center',
              )}
            >
              {formatter && item?.value !== undefined && item.name ? (
                formatter(item.value, item.name, item, index, item.payload)
              ) : (
                <>
                  {itemConfig?.icon ? (
                    <itemConfig.icon />
                  ) : (
                    !hideIndicator && (
                      <div
                        className={cn(
                          'shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)',
                          {
                            'h-2.5 w-2.5': indicator === 'dot',
                            'w-1': indicator === 'line',
                            'w-0 border-[1.5px] border-dashed bg-transparent':
                              indicator === 'dashed',
                            'my-0.5': nestLabel && indicator === 'dashed',
                          },
                        )}
                        style={
                          {
                            '--color-bg': indicatorColor,
                            '--color-border': indicatorColor,
                          } as React.CSSProperties
                        }
                      />
                    )
                  )}
                  <div
                    className={cn(
                      'flex flex-1 justify-between leading-none',
                      nestLabel ? 'items-end' : 'items-center',
                    )}
                  >
                    <div className="grid gap-1.5">
                      {nestLabel ? tooltipLabel : null}
                      <span className="text-muted-foreground">
                        {itemConfig?.label || item.name}
                      </span>
                    </div>
                    {item.value && (
                      <span className="text-foreground font-mono font-medium tabular-nums">
                        {item.value.toLocaleString()}
                      </span>
                    )}
                  </div>
                </>
              )}
            </div>
          )
        })}
      </div>
    </div>
  )
}

const ChartLegend = RechartsPrimitive.Legend

function ChartLegendContent({
  className,
  hideIcon = false,
  payload,
  verticalAlign = 'bottom',
  nameKey,
}: React.ComponentProps<'div'> &
  Pick<RechartsPrimitive.LegendProps, 'payload' | 'verticalAlign'> & {
    hideIcon?: boolean
    nameKey?: string
  }) {
  const { config } = useChart()

if (!payload?.length) {
    return null
  }

return (
    <div
      className={cn(
        'flex items-center justify-center gap-4',
        verticalAlign === 'top' ? 'pb-3' : 'pt-3',
        className,
      )}
    >
      {payload.map((item) => {
        const key = `${nameKey || item.dataKey || 'value'}`
        const itemConfig = getPayloadConfigFromPayload(config, item, key)

return (
          <div
            key={item.value}
            className={
              '[&>svg]:text-muted-foreground flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3'
            }
          >
            {itemConfig?.icon && !hideIcon ? (
              <itemConfig.icon />
            ) : (
              <div
                className="h-2 w-2 shrink-0 rounded-[2px]"
                style={{
                  backgroundColor: item.color,
                }}
              />
            )}
            {itemConfig?.label}
          </div>
        )
      })}
    </div>
  )
}

// Helper to extract item config from a payload.
function getPayloadConfigFromPayload(
  config: ChartConfig,
  payload: unknown,
  key: string,
) {
  if (typeof payload !== 'object' || payload === null) {
    return undefined
  }

const payloadPayload =
    'payload' in payload &&
    typeof payload.payload === 'object' &&
    payload.payload !== null
      ? payload.payload
      : undefined

let configLabelKey: string = key

if (
    key in payload &&
    typeof payload[key as keyof typeof payload] === 'string'
  ) {
    configLabelKey = payload[key as keyof typeof payload] as string
  } else if (
    payloadPayload &&
    key in payloadPayload &&
    typeof payloadPayload[key as keyof typeof payloadPayload] === 'string'
  ) {
    configLabelKey = payloadPayload[
      key as keyof typeof payloadPayload
    ] as string
  }

return configLabelKey in config
    ? config[configLabelKey]
    : config[key as keyof typeof config]
}

export {
  ChartContainer,
  ChartTooltip,
  ChartTooltipContent,
  ChartLegend,
  ChartLegendContent,
  ChartStyle,
}
[V0_FILE]typescript:file="lib/security-center.ts" isMerged="true"
import { createClient } from "@/lib/supabase/client"

// Device fingerprint for device management
export interface DeviceInfo {
  id: string
  name: string
  type: "mobile" | "desktop" | "tablet"
  browser: string
  os: string
  ip: string
  location?: string
  lastActive: Date
  isTrusted: boolean
  isCurrentDevice: boolean
}

// Security settings
export interface SecuritySettings {
  // Session & Lock
  autoLockTimeout: number // minutes, 0 = disabled
  requireAuthForTransactions: boolean
  sessionTimeout: number // minutes
  
  // Transaction Protection
  spendingLimitDaily: number // in USD
  spendingLimitWeekly: number
  requireMFAForLargeTransactions: boolean
  largeTransactionThreshold: number // in USD
  
  // Whitelisting
  whitelistEnabled: boolean
  whitelistedAddresses: WhitelistedAddress[]
  
  // Notifications
  emailAlerts: boolean
  pushAlerts: boolean
  loginAlerts: boolean
  transactionAlerts: boolean
  
  // Biometric (for future implementation)
  biometricEnabled: boolean
  
  // Anti-Phishing
  antiPhishingCode: string
}

export interface WhitelistedAddress {
  address: string
  label: string
  addedAt: Date
}

export interface SecurityEvent {
  id: string
  type: SecurityEventType
  timestamp: Date
  device: string
  ip: string
  location?: string
  details?: Record<string, any>
  severity: "low" | "medium" | "high" | "critical"
}

// Default security settings (like Coinbase defaults)
export const DEFAULT_SECURITY_SETTINGS: SecuritySettings = {
  autoLockTimeout: 5,
  requireAuthForTransactions: true,
  sessionTimeout: 30,
  spendingLimitDaily: 1000,
  spendingLimitWeekly: 5000,
  requireMFAForLargeTransactions: true,
  largeTransactionThreshold: 500,
  whitelistEnabled: false,
  whitelistedAddresses: [],
  emailAlerts: true,
  pushAlerts: false,
  loginAlerts: true,
  transactionAlerts: true,
  biometricEnabled: false,
  antiPhishingCode: "",
}

// Get browser/device info
export function getDeviceInfo(): Partial<DeviceInfo> {
  if (typeof window === "undefined") return {}
  
  const ua = navigator.userAgent
  const isMobile = /iPhone|iPad|iPod|Android/i.test(ua)
  const isTablet = /iPad|Tablet/i.test(ua)
  
  let browser = "Unknown"
  if (ua.includes("Chrome")) browser = "Chrome"
  else if (ua.includes("Safari")) browser = "Safari"
  else if (ua.includes("Firefox")) browser = "Firefox"
  else if (ua.includes("Edge")) browser = "Edge"
  
  let os = "Unknown"
  if (ua.includes("Windows")) os = "Windows"
  else if (ua.includes("Mac")) os = "macOS"
  else if (ua.includes("Linux")) os = "Linux"
  else if (ua.includes("Android")) os = "Android"
  else if (ua.includes("iOS") || ua.includes("iPhone")) os = "iOS"
  
  return {
    type: isTablet ? "tablet" : isMobile ? "mobile" : "desktop",
    browser,
    os,
    name: `${browser} on ${os}`,
  }
}

// Generate device fingerprint
export function generateDeviceFingerprint(): string {
  if (typeof window === "undefined") return ""
  
  const canvas = document.createElement("canvas")
  const ctx = canvas.getContext("2d")
  if (ctx) {
    ctx.textBaseline = "top"
    ctx.font = "14px Arial"
    ctx.fillText("LinkFiCrypto", 2, 2)
  }
  
  const fingerprint = [
    navigator.userAgent,
    navigator.language,
    screen.width,
    screen.height,
    screen.colorDepth,
    new Date().getTimezoneOffset(),
    canvas.toDataURL(),
  ].join("|")
  
  // Simple hash
  let hash = 0
  for (let i = 0; i < fingerprint.length; i++) {
    const char = fingerprint.charCodeAt(i)
    hash = ((hash << 5) - hash) + char
    hash = hash & hash
  }
  
  return Math.abs(hash).toString(36)
}

// Log security event
export async function logSecurityEvent(
  userId: string,
  type: SecurityEventType,
  details?: Record<string, any>,
  severity: "low" | "medium" | "high" | "critical" = "low"
): Promise<void> {
  const supabase = createClient()
  const deviceInfo = getDeviceInfo()
  const deviceFingerprint = generateDeviceFingerprint()
  
  try {
    await supabase.from("security_events").insert({
      user_id: userId,
      event_type: type,
      device_fingerprint: deviceFingerprint,
      device_info: deviceInfo,
      details,
      severity,
      ip_address: "", // Would need server-side to get real IP
    })
  } catch (error) {
    console.error("Failed to log security event:", error)
  }
}

// Get security settings
export async function getSecuritySettings(userId: string): Promise<SecuritySettings> {
  const supabase = createClient()
  
  const { data } = await supabase
    .from("security_settings")
    .select("*")
    .eq("user_id", userId)
    .single()
  
  if (!data) {
    return DEFAULT_SECURITY_SETTINGS
  }
  
  return {
    autoLockTimeout: data.auto_lock_timeout ?? DEFAULT_SECURITY_SETTINGS.autoLockTimeout,
    requireAuthForTransactions: data.require_auth_for_transactions ?? DEFAULT_SECURITY_SETTINGS.requireAuthForTransactions,
    sessionTimeout: data.session_timeout ?? DEFAULT_SECURITY_SETTINGS.sessionTimeout,
    spendingLimitDaily: data.spending_limit_daily ?? DEFAULT_SECURITY_SETTINGS.spendingLimitDaily,
    spendingLimitWeekly: data.spending_limit_weekly ?? DEFAULT_SECURITY_SETTINGS.spendingLimitWeekly,
    requireMFAForLargeTransactions: data.require_mfa_for_large_transactions ?? DEFAULT_SECURITY_SETTINGS.requireMFAForLargeTransactions,
    largeTransactionThreshold: data.large_transaction_threshold ?? DEFAULT_SECURITY_SETTINGS.largeTransactionThreshold,
    whitelistEnabled: data.whitelist_enabled ?? DEFAULT_SECURITY_SETTINGS.whitelistEnabled,
    whitelistedAddresses: data.whitelisted_addresses ?? DEFAULT_SECURITY_SETTINGS.whitelistedAddresses,
    emailAlerts: data.email_alerts ?? DEFAULT_SECURITY_SETTINGS.emailAlerts,
    pushAlerts: data.push_alerts ?? DEFAULT_SECURITY_SETTINGS.pushAlerts,
    loginAlerts: data.login_alerts ?? DEFAULT_SECURITY_SETTINGS.loginAlerts,
    transactionAlerts: data.transaction_alerts ?? DEFAULT_SECURITY_SETTINGS.transactionAlerts,
    biometricEnabled: data.biometric_enabled ?? DEFAULT_SECURITY_SETTINGS.biometricEnabled,
    antiPhishingCode: data.anti_phishing_code ?? DEFAULT_SECURITY_SETTINGS.antiPhishingCode,
  }
}

// Update security settings
export async function updateSecuritySettings(
  userId: string,
  settings: Partial<SecuritySettings>
): Promise<boolean> {
  const supabase = createClient()
  
  const dbSettings: Record<string, any> = {}
  
  if (settings.autoLockTimeout !== undefined) dbSettings.auto_lock_timeout = settings.autoLockTimeout
  if (settings.requireAuthForTransactions !== undefined) dbSettings.require_auth_for_transactions = settings.requireAuthForTransactions
  if (settings.sessionTimeout !== undefined) dbSettings.session_timeout = settings.sessionTimeout
  if (settings.spendingLimitDaily !== undefined) dbSettings.spending_limit_daily = settings.spendingLimitDaily
  if (settings.spendingLimitWeekly !== undefined) dbSettings.spending_limit_weekly = settings.spendingLimitWeekly
  if (settings.requireMFAForLargeTransactions !== undefined) dbSettings.require_mfa_for_large_transactions = settings.requireMFAForLargeTransactions
  if (settings.largeTransactionThreshold !== undefined) dbSettings.large_transaction_threshold = settings.largeTransactionThreshold
  if (settings.whitelistEnabled !== undefined) dbSettings.whitelist_enabled = settings.whitelistEnabled
  if (settings.whitelistedAddresses !== undefined) dbSettings.whitelisted_addresses = settings.whitelistedAddresses
  if (settings.emailAlerts !== undefined) dbSettings.email_alerts = settings.emailAlerts
  if (settings.pushAlerts !== undefined) dbSettings.push_alerts = settings.pushAlerts
  if (settings.loginAlerts !== undefined) dbSettings.login_alerts = settings.loginAlerts
  if (settings.transactionAlerts !== undefined) dbSettings.transaction_alerts = settings.transactionAlerts
  if (settings.biometricEnabled !== undefined) dbSettings.biometric_enabled = settings.biometricEnabled
  if (settings.antiPhishingCode !== undefined) dbSettings.anti_phishing_code = settings.antiPhishingCode
  
  dbSettings.updated_at = new Date().toISOString()
  
  const { error } = await supabase
    .from("security_settings")
    .upsert({
      user_id: userId,
      ...dbSettings,
    })
  
  return !error
}

// Check if address is whitelisted
export async function isAddressWhitelisted(userId: string, address: string): Promise<boolean> {
  const settings = await getSecuritySettings(userId)
  
  if (!settings.whitelistEnabled) return true // Whitelist disabled = all addresses allowed
  
  return settings.whitelistedAddresses.some(
    (wa) => wa.address.toLowerCase() === address.toLowerCase()
  )
}

// Check spending limits
export async function checkSpendingLimits(
  userId: string,
  amountUSD: number
): Promise<{ allowed: boolean; reason?: string; requiresMFA?: boolean }> {
  const supabase = createClient()
  const settings = await getSecuritySettings(userId)
  
  // Get recent transactions
  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
  const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString()
  
  const { data: dailyTxs } = await supabase
    .from("transactions")
    .select("amount")
    .eq("user_id", userId)
    .eq("type", "send")
    .gte("created_at", oneDayAgo)
  
  const { data: weeklyTxs } = await supabase
    .from("transactions")
    .select("amount")
    .eq("user_id", userId)
    .eq("type", "send")
    .gte("created_at", oneWeekAgo)
  
  const dailyTotal = (dailyTxs || []).reduce((sum, tx) => sum + (tx.amount || 0), 0)
  const weeklyTotal = (weeklyTxs || []).reduce((sum, tx) => sum + (tx.amount || 0), 0)
  
  // Check daily limit
  if (dailyTotal + amountUSD > settings.spendingLimitDaily) {
    return {
      allowed: false,
      reason: `This transaction would exceed your daily spending limit of $${settings.spendingLimitDaily}`,
    }
  }
  
  // Check weekly limit
  if (weeklyTotal + amountUSD > settings.spendingLimitWeekly) {
    return {
      allowed: false,
      reason: `This transaction would exceed your weekly spending limit of $${settings.spendingLimitWeekly}`,
    }
  }
  
  // Check if MFA required for large transactions
  if (settings.requireMFAForLargeTransactions && amountUSD >= settings.largeTransactionThreshold) {
    return {
      allowed: true,
      requiresMFA: true,
    }
  }
  
  return { allowed: true }
}

// Generate anti-phishing code
export function generateAntiPhishingCode(): string {
  const words = ["secure", "verified", "trusted", "safe", "protected"]
  const colors = ["red", "blue", "green", "gold", "silver"]
  const animals = ["lion", "eagle", "wolf", "bear", "shark"]
  
  const word = words[Math.floor(Math.random() * words.length)]
  const color = colors[Math.floor(Math.random() * colors.length)]
  const animal = animals[Math.floor(Math.random() * animals.length)]
  const number = Math.floor(Math.random() * 100)
  
  return `${color}-${animal}-${word}-${number}`
}

// Session lock management
export function setupAutoLock(timeoutMinutes: number, onLock: () => void): () => void {
  if (typeof window === "undefined" || timeoutMinutes <= 0) return () => {}
  
  let timeoutId: NodeJS.Timeout
  let lastActivity = Date.now()
  
  const resetTimer = () => {
    lastActivity = Date.now()
    clearTimeout(timeoutId)
    timeoutId = setTimeout(() => {
      onLock()
    }, timeoutMinutes * 60 * 1000)
  }
  
  const events = ["mousedown", "keydown", "scroll", "touchstart"]
  events.forEach((event) => {
    window.addEventListener(event, resetTimer)
  })
  
  resetTimer()
  
  // Cleanup function
  return () => {
    clearTimeout(timeoutId)
    events.forEach((event) => {
      window.removeEventListener(event, resetTimer)
    })
  }
}

// Validate transaction before sending
export async function validateTransaction(
  userId: string,
  toAddress: string,
  amountUSD: number
): Promise<{ valid: boolean; errors: string[]; warnings: string[]; requiresMFA: boolean }> {
  const errors: string[] = []
  const warnings: string[] = []
  let requiresMFA = false
  
  // Check whitelist
  const isWhitelisted = await isAddressWhitelisted(userId, toAddress)
  if (!isWhitelisted) {
    errors.push("Recipient address is not in your whitelist. Add it first to send funds.")
  }
  
  // Check spending limits
  const spendingCheck = await checkSpendingLimits(userId, amountUSD)
  if (!spendingCheck.allowed) {
    errors.push(spendingCheck.reason || "Transaction exceeds spending limits")
  }
  if (spendingCheck.requiresMFA) {
    requiresMFA = true
    warnings.push("This large transaction requires MFA verification")
  }
  
  // Warn about new addresses
  const supabase = createClient()
  const { data: previousTxs } = await supabase
    .from("transactions")
    .select("id")
    .eq("user_id", userId)
    .eq("to_address", toAddress.toLowerCase())
    .limit(1)
  
  if (!previousTxs || previousTxs.length === 0) {
    warnings.push("You have never sent to this address before. Please verify it carefully.")
  }
  
  return {
    valid: errors.length === 0,
    errors,
    warnings,
    requiresMFA,
  }
}
[V0_FILE]sql:file="scripts/010_create_security_tables.sql" isMerged="true"
-- Security settings table for advanced security features
CREATE TABLE IF NOT EXISTS security_settings (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  
  -- Session & Lock Settings
  auto_lock_timeout INTEGER DEFAULT 5, -- minutes
  require_auth_for_transactions BOOLEAN DEFAULT true,
  session_timeout INTEGER DEFAULT 30, -- minutes
  
  -- Spending Limits
  spending_limit_daily NUMERIC DEFAULT 1000, -- in USD
  spending_limit_weekly NUMERIC DEFAULT 5000,
  require_mfa_for_large_transactions BOOLEAN DEFAULT true,
  large_transaction_threshold NUMERIC DEFAULT 500, -- in USD
  
  -- Address Whitelisting
  whitelist_enabled BOOLEAN DEFAULT false,
  whitelisted_addresses JSONB DEFAULT '[]'::jsonb,
  
  -- Notification Settings
  email_alerts BOOLEAN DEFAULT true,
  push_alerts BOOLEAN DEFAULT false,
  login_alerts BOOLEAN DEFAULT true,
  transaction_alerts BOOLEAN DEFAULT true,
  
  -- Biometric (future)
  biometric_enabled BOOLEAN DEFAULT false,
  
  -- Anti-Phishing
  anti_phishing_code TEXT,
  
  -- Timestamps
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  
  UNIQUE(user_id)
);

-- Security events/audit log table
CREATE TABLE IF NOT EXISTS security_events (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  event_type TEXT NOT NULL,
  device_fingerprint TEXT,
  device_info JSONB,
  ip_address TEXT,
  location TEXT,
  details JSONB,
  severity TEXT DEFAULT 'low' CHECK (severity IN ('low', 'medium', 'high', 'critical')),
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Trusted devices table
CREATE TABLE IF NOT EXISTS trusted_devices (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  device_fingerprint TEXT NOT NULL,
  device_name TEXT,
  device_type TEXT,
  browser TEXT,
  os TEXT,
  ip_address TEXT,
  location TEXT,
  is_trusted BOOLEAN DEFAULT false,
  last_active TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  
  UNIQUE(user_id, device_fingerprint)
);

-- Session tokens for secure session management
CREATE TABLE IF NOT EXISTS active_sessions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  session_token TEXT NOT NULL UNIQUE,
  device_fingerprint TEXT,
  device_info JSONB,
  ip_address TEXT,
  expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  last_active TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Create indexes for better performance
CREATE INDEX IF NOT EXISTS idx_security_settings_user_id ON security_settings(user_id);
CREATE INDEX IF NOT EXISTS idx_security_events_user_id ON security_events(user_id);
CREATE INDEX IF NOT EXISTS idx_security_events_created_at ON security_events(created_at DESC);
CREATE INDEX IF NOT EXISTS idx_security_events_type ON security_events(event_type);
CREATE INDEX IF NOT EXISTS idx_trusted_devices_user_id ON trusted_devices(user_id);
CREATE INDEX IF NOT EXISTS idx_active_sessions_user_id ON active_sessions(user_id);
CREATE INDEX IF NOT EXISTS idx_active_sessions_token ON active_sessions(session_token);

-- Enable RLS
ALTER TABLE security_settings ENABLE ROW LEVEL SECURITY;
ALTER TABLE security_events ENABLE ROW LEVEL SECURITY;
ALTER TABLE trusted_devices ENABLE ROW LEVEL SECURITY;
ALTER TABLE active_sessions ENABLE ROW LEVEL SECURITY;

-- RLS Policies for security_settings
CREATE POLICY "security_settings_select_own" ON security_settings
  FOR SELECT TO authenticated
  USING (auth.uid() = user_id);

CREATE POLICY "security_settings_insert_own" ON security_settings
  FOR INSERT TO authenticated
  WITH CHECK (auth.uid() = user_id);

CREATE POLICY "security_settings_update_own" ON security_settings
  FOR UPDATE TO authenticated
  USING (auth.uid() = user_id)
  WITH CHECK (auth.uid() = user_id);

-- RLS Policies for security_events
CREATE POLICY "security_events_select_own" ON security_events
  FOR SELECT TO authenticated
  USING (auth.uid() = user_id);

CREATE POLICY "security_events_insert_own" ON security_events
  FOR INSERT TO authenticated
  WITH CHECK (auth.uid() = user_id);

-- RLS Policies for trusted_devices
CREATE POLICY "trusted_devices_select_own" ON trusted_devices
  FOR SELECT TO authenticated
  USING (auth.uid() = user_id);

CREATE POLICY "trusted_devices_insert_own" ON trusted_devices
  FOR INSERT TO authenticated
  WITH CHECK (auth.uid() = user_id);

CREATE POLICY "trusted_devices_update_own" ON trusted_devices
  FOR UPDATE TO authenticated
  USING (auth.uid() = user_id);

CREATE POLICY "trusted_devices_delete_own" ON trusted_devices
  FOR DELETE TO authenticated
  USING (auth.uid() = user_id);

-- RLS Policies for active_sessions
CREATE POLICY "active_sessions_select_own" ON active_sessions
  FOR SELECT TO authenticated
  USING (auth.uid() = user_id);

CREATE POLICY "active_sessions_insert_own" ON active_sessions
  FOR INSERT TO authenticated
  WITH CHECK (auth.uid() = user_id);

CREATE POLICY "active_sessions_delete_own" ON active_sessions
  FOR DELETE TO authenticated
  USING (auth.uid() = user_id);
[V0_FILE]typescriptreact:file="components/security-center.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClient } from "@/lib/supabase/client"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Switch } from "@/components/ui/switch"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { Badge } from "@/components/ui/badge"
import { Slider } from "@/components/ui/slider"
import {
  Shield,
  Lock,
  Smartphone,
  Bell,
  Clock,
  DollarSign,
  AlertTriangle,
  Check,
  X,
  Plus,
  Trash2,
  Eye,
  EyeOff,
  Fingerprint,
  Key,
  Monitor,
  Activity,
  ShieldCheck,
  ShieldAlert,
  Copy,
  RefreshCw,
} from "lucide-react"
import {
  SecuritySettings,
  DEFAULT_SECURITY_SETTINGS,
  getSecuritySettings,
  updateSecuritySettings,
  generateAntiPhishingCode,
  logSecurityEvent,
  getDeviceInfo,
} from "@/lib/security-center"
import { isMFAEnabled } from "@/lib/mfa"

interface SecurityCenterProps {
  userId: string
  onClose?: () => void
}

export function SecurityCenter({ userId, onClose }: SecurityCenterProps) {
  const [settings, setSettings] = useState<SecuritySettings>(DEFAULT_SECURITY_SETTINGS)
  const [loading, setLoading] = useState(true)
  const [saving, setSaving] = useState(false)
  const [mfaEnabled, setMfaEnabled] = useState(false)
  const [securityScore, setSecurityScore] = useState(0)
  const [newWhitelistAddress, setNewWhitelistAddress] = useState("")
  const [newWhitelistLabel, setNewWhitelistLabel] = useState("")
  const [showAntiPhishing, setShowAntiPhishing] = useState(false)
  const [recentEvents, setRecentEvents] = useState<any[]>([])
  const [trustedDevices, setTrustedDevices] = useState<any[]>([])
  const supabase = createClient()

useEffect(() => {
    loadSettings()
  }, [userId])

const loadSettings = async () => {
    setLoading(true)
    try {
      const securitySettings = await getSecuritySettings(userId)
      setSettings(securitySettings)
      
      const mfa = await isMFAEnabled(userId)
      setMfaEnabled(mfa)
      
      // Calculate security score
      calculateSecurityScore(securitySettings, mfa)
      
      // Load recent security events
      const { data: events } = await supabase
        .from("security_events")
        .select("*")
        .eq("user_id", userId)
        .order("created_at", { ascending: false })
        .limit(10)
      
      setRecentEvents(events || [])
      
      // Load trusted devices
      const { data: devices } = await supabase
        .from("trusted_devices")
        .select("*")
        .eq("user_id", userId)
        .order("last_active", { ascending: false })
      
      setTrustedDevices(devices || [])
    } catch (error) {
      console.error("Failed to load security settings:", error)
    } finally {
      setLoading(false)
    }
  }

const calculateSecurityScore = (settings: SecuritySettings, mfa: boolean) => {
    let score = 0
    const maxScore = 100
    
    // MFA enabled (+25)
    if (mfa) score += 25
    
    // Auto-lock enabled (+15)
    if (settings.autoLockTimeout > 0 && settings.autoLockTimeout <= 10) score += 15
    else if (settings.autoLockTimeout > 10) score += 10
    
    // Require auth for transactions (+10)
    if (settings.requireAuthForTransactions) score += 10
    
    // Spending limits set (+10)
    if (settings.spendingLimitDaily < 5000) score += 10
    
    // MFA for large transactions (+10)
    if (settings.requireMFAForLargeTransactions) score += 10
    
    // Whitelist enabled (+10)
    if (settings.whitelistEnabled) score += 10
    
    // Email alerts enabled (+5)
    if (settings.emailAlerts) score += 5
    
    // Transaction alerts (+5)
    if (settings.transactionAlerts) score += 5
    
    // Anti-phishing code set (+5)
    if (settings.antiPhishingCode) score += 5
    
    setSecurityScore(Math.min(score, maxScore))
  }

const handleSaveSettings = async (newSettings: Partial<SecuritySettings>) => {
    setSaving(true)
    try {
      const updated = { ...settings, ...newSettings }
      await updateSecuritySettings(userId, newSettings)
      setSettings(updated)
      calculateSecurityScore(updated, mfaEnabled)
      
      await logSecurityEvent(userId, "spending_limit_updated", newSettings, "low")
    } catch (error) {
      console.error("Failed to save settings:", error)
    } finally {
      setSaving(false)
    }
  }

const addWhitelistAddress = async () => {
    if (!newWhitelistAddress || !newWhitelistLabel) return
    
    const newAddress = {
      address: newWhitelistAddress,
      label: newWhitelistLabel,
      addedAt: new Date(),
    }
    
    const updated = [...settings.whitelistedAddresses, newAddress]
    await handleSaveSettings({ whitelistedAddresses: updated })
    
    await logSecurityEvent(userId, "whitelist_updated", { action: "add", address: newWhitelistAddress }, "low")
    
    setNewWhitelistAddress("")
    setNewWhitelistLabel("")
  }

const removeWhitelistAddress = async (address: string) => {
    const updated = settings.whitelistedAddresses.filter(
      (wa) => wa.address.toLowerCase() !== address.toLowerCase()
    )
    await handleSaveSettings({ whitelistedAddresses: updated })
    
    await logSecurityEvent(userId, "whitelist_updated", { action: "remove", address }, "low")
  }

const generateNewAntiPhishingCode = async () => {
    const code = generateAntiPhishingCode()
    await handleSaveSettings({ antiPhishingCode: code })
  }

const removeDevice = async (deviceId: string) => {
    await supabase.from("trusted_devices").delete().eq("id", deviceId)
    setTrustedDevices(trustedDevices.filter((d) => d.id !== deviceId))
  }

const getScoreColor = () => {
    if (securityScore >= 80) return "text-green-500"
    if (securityScore >= 60) return "text-yellow-500"
    if (securityScore >= 40) return "text-orange-500"
    return "text-red-500"
  }

const getScoreBg = () => {
    if (securityScore >= 80) return "bg-green-500"
    if (securityScore >= 60) return "bg-yellow-500"
    if (securityScore >= 40) return "bg-orange-500"
    return "bg-red-500"
  }

const getEventIcon = (type: string) => {
    switch (type) {
      case "login_success": return <Check className="w-4 h-4 text-green-500" />
      case "login_failed": return <X className="w-4 h-4 text-red-500" />
      case "password_changed": return <Key className="w-4 h-4 text-blue-500" />
      case "mfa_enabled": return <ShieldCheck className="w-4 h-4 text-green-500" />
      case "mfa_disabled": return <ShieldAlert className="w-4 h-4 text-orange-500" />
      case "wallet_export": return <AlertTriangle className="w-4 h-4 text-red-500" />
      case "large_transaction": return <DollarSign className="w-4 h-4 text-yellow-500" />
      default: return <Activity className="w-4 h-4 text-gray-500" />
    }
  }

if (loading) {
    return (
      <div className="flex items-center justify-center p-8">
        <div className="w-8 h-8 border-4 border-primary border-t-transparent rounded-full animate-spin" />
      </div>
    )
  }

return (
    <div className="space-y-6">
      {/* Security Score Header */}
      <Card className="bg-gradient-to-br from-gray-900 to-gray-800 border-gray-700">
        <CardContent className="p-6">
          <div className="flex items-center justify-between">
            <div className="flex items-center gap-4">
              <div className={`w-20 h-20 rounded-full border-4 ${getScoreBg()} flex items-center justify-center`}>
                <span className="text-2xl font-bold text-white">{securityScore}</span>
              </div>
              <div>
                <h2 className="text-xl font-bold text-white">Security Score</h2>
                <p className="text-gray-400">
                  {securityScore >= 80 ? "Excellent protection" :
                   securityScore >= 60 ? "Good protection, room for improvement" :
                   securityScore >= 40 ? "Moderate protection, consider enabling more features" :
                   "Low protection, enable security features"}
                </p>
              </div>
            </div>
            <div className="flex items-center gap-2">
              {mfaEnabled ? (
                <Badge className="bg-green-500">2FA Enabled</Badge>
              ) : (
                <Badge variant="destructive">2FA Disabled</Badge>
              )}
            </div>
          </div>
        </CardContent>
      </Card>

<Tabs defaultValue="protection" className="w-full">
        <TabsList className="grid w-full grid-cols-4">
          <TabsTrigger value="protection" className="flex items-center gap-2">
            <Shield className="w-4 h-4" />
            <span className="hidden sm:inline">Protection</span>
          </TabsTrigger>
          <TabsTrigger value="limits" className="flex items-center gap-2">
            <DollarSign className="w-4 h-4" />
            <span className="hidden sm:inline">Limits</span>
          </TabsTrigger>
          <TabsTrigger value="devices" className="flex items-center gap-2">
            <Smartphone className="w-4 h-4" />
            <span className="hidden sm:inline">Devices</span>
          </TabsTrigger>
          <TabsTrigger value="activity" className="flex items-center gap-2">
            <Activity className="w-4 h-4" />
            <span className="hidden sm:inline">Activity</span>
          </TabsTrigger>
        </TabsList>

{/* Protection Tab */}
        <TabsContent value="protection" className="space-y-4">
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <Lock className="w-5 h-5" />
                Session & Lock Settings
              </CardTitle>
              <CardDescription>
                Control how your wallet locks and session management
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-6">
              <div className="space-y-4">
                <div className="flex items-center justify-between">
                  <div className="space-y-0.5">
                    <Label>Auto-Lock Timeout</Label>
                    <p className="text-sm text-muted-foreground">
                      Lock wallet after {settings.autoLockTimeout} minutes of inactivity
                    </p>
                  </div>
                  <div className="w-48">
                    <Slider
                      value={[settings.autoLockTimeout]}
                      onValueChange={(v) => handleSaveSettings({ autoLockTimeout: v[0] })}
                      min={0}
                      max={30}
                      step={1}
                    />
                    <p className="text-xs text-center mt-1 text-muted-foreground">
                      {settings.autoLockTimeout === 0 ? "Disabled" : `${settings.autoLockTimeout} min`}
                    </p>
                  </div>
                </div>

<div className="flex items-center justify-between">
                  <div className="space-y-0.5">
                    <Label>Require Password for Transactions</Label>
                    <p className="text-sm text-muted-foreground">
                      Always verify identity before sending crypto
                    </p>
                  </div>
                  <Switch
                    checked={settings.requireAuthForTransactions}
                    onCheckedChange={(v) => handleSaveSettings({ requireAuthForTransactions: v })}
                  />
                </div>

<div className="flex items-center justify-between">
                  <div className="space-y-0.5">
                    <Label>Session Timeout</Label>
                    <p className="text-sm text-muted-foreground">
                      Auto-logout after {settings.sessionTimeout} minutes
                    </p>
                  </div>
                  <div className="w-48">
                    <Slider
                      value={[settings.sessionTimeout]}
                      onValueChange={(v) => handleSaveSettings({ sessionTimeout: v[0] })}
                      min={5}
                      max={120}
                      step={5}
                    />
                    <p className="text-xs text-center mt-1 text-muted-foreground">
                      {settings.sessionTimeout} min
                    </p>
                  </div>
                </div>
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <Bell className="w-5 h-5" />
                Security Alerts
              </CardTitle>
              <CardDescription>
                Get notified about important security events
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="flex items-center justify-between">
                <div className="space-y-0.5">
                  <Label>Email Alerts</Label>
                  <p className="text-sm text-muted-foreground">Receive security alerts via email</p>
                </div>
                <Switch
                  checked={settings.emailAlerts}
                  onCheckedChange={(v) => handleSaveSettings({ emailAlerts: v })}
                />
              </div>

<div className="flex items-center justify-between">
                <div className="space-y-0.5">
                  <Label>Login Alerts</Label>
                  <p className="text-sm text-muted-foreground">Alert on new device logins</p>
                </div>
                <Switch
                  checked={settings.loginAlerts}
                  onCheckedChange={(v) => handleSaveSettings({ loginAlerts: v })}
                />
              </div>

<div className="flex items-center justify-between">
                <div className="space-y-0.5">
                  <Label>Transaction Alerts</Label>
                  <p className="text-sm text-muted-foreground">Alert on all transactions</p>
                </div>
                <Switch
                  checked={settings.transactionAlerts}
                  onCheckedChange={(v) => handleSaveSettings({ transactionAlerts: v })}
                />
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <ShieldCheck className="w-5 h-5" />
                Anti-Phishing Protection
              </CardTitle>
              <CardDescription>
                A unique code shown on legitimate LinkFiCrypto emails to verify authenticity
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              {settings.antiPhishingCode ? (
                <div className="flex items-center justify-between p-4 bg-green-50 dark:bg-green-950 border border-green-200 dark:border-green-800 rounded-lg">
                  <div>
                    <p className="text-sm text-muted-foreground">Your anti-phishing code:</p>
                    <p className="text-lg font-mono font-bold text-green-600">
                      {showAntiPhishing ? settings.antiPhishingCode : "••••••••••••"}
                    </p>
                  </div>
                  <div className="flex items-center gap-2">
                    <Button
                      variant="ghost"
                      size="sm"
                      onClick={() => setShowAntiPhishing(!showAntiPhishing)}
                    >
                      {showAntiPhishing ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                    </Button>
                    <Button
                      variant="ghost"
                      size="sm"
                      onClick={() => navigator.clipboard.writeText(settings.antiPhishingCode)}
                    >
                      <Copy className="w-4 h-4" />
                    </Button>
                    <Button
                      variant="outline"
                      size="sm"
                      onClick={generateNewAntiPhishingCode}
                    >
                      <RefreshCw className="w-4 h-4 mr-1" />
                      Regenerate
                    </Button>
                  </div>
                </div>
              ) : (
                <Button onClick={generateNewAntiPhishingCode}>
                  Generate Anti-Phishing Code
                </Button>
              )}
            </CardContent>
          </Card>
        </TabsContent>

{/* Spending Limits Tab */}
        <TabsContent value="limits" className="space-y-4">
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <DollarSign className="w-5 h-5" />
                Spending Limits
              </CardTitle>
              <CardDescription>
                Set limits to protect against unauthorized large transfers
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-6">
              <div className="space-y-4">
                <div className="space-y-2">
                  <Label>Daily Spending Limit (USD)</Label>
                  <div className="flex items-center gap-2">
                    <Input
                      type="number"
                      value={settings.spendingLimitDaily}
                      onChange={(e) => handleSaveSettings({ spendingLimitDaily: Number(e.target.value) })}
                      className="w-32"
                    />
                    <span className="text-muted-foreground">USD per day</span>
                  </div>
                </div>

<div className="space-y-2">
                  <Label>Weekly Spending Limit (USD)</Label>
                  <div className="flex items-center gap-2">
                    <Input
                      type="number"
                      value={settings.spendingLimitWeekly}
                      onChange={(e) => handleSaveSettings({ spendingLimitWeekly: Number(e.target.value) })}
                      className="w-32"
                    />
                    <span className="text-muted-foreground">USD per week</span>
                  </div>
                </div>
              </div>

<div className="border-t pt-4 space-y-4">
                <div className="flex items-center justify-between">
                  <div className="space-y-0.5">
                    <Label>Require 2FA for Large Transactions</Label>
                    <p className="text-sm text-muted-foreground">
                      Extra verification for transactions over ${settings.largeTransactionThreshold}
                    </p>
                  </div>
                  <Switch
                    checked={settings.requireMFAForLargeTransactions}
                    onCheckedChange={(v) => handleSaveSettings({ requireMFAForLargeTransactions: v })}
                  />
                </div>

{settings.requireMFAForLargeTransactions && (
                  <div className="space-y-2">
                    <Label>Large Transaction Threshold (USD)</Label>
                    <div className="flex items-center gap-2">
                      <Input
                        type="number"
                        value={settings.largeTransactionThreshold}
                        onChange={(e) => handleSaveSettings({ largeTransactionThreshold: Number(e.target.value) })}
                        className="w-32"
                      />
                      <span className="text-muted-foreground">USD</span>
                    </div>
                  </div>
                )}
              </div>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <ShieldCheck className="w-5 h-5" />
                Address Whitelist
              </CardTitle>
              <CardDescription>
                Only allow transfers to pre-approved addresses (like Coinbase Vault)
              </CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="flex items-center justify-between">
                <div className="space-y-0.5">
                  <Label>Enable Address Whitelist</Label>
                  <p className="text-sm text-muted-foreground">
                    Only send to whitelisted addresses
                  </p>
                </div>
                <Switch
                  checked={settings.whitelistEnabled}
                  onCheckedChange={(v) => handleSaveSettings({ whitelistEnabled: v })}
                />
              </div>

{settings.whitelistEnabled && (
                <>
                  <div className="flex gap-2">
                    <Input
                      placeholder="Wallet address (0x...)"
                      value={newWhitelistAddress}
                      onChange={(e) => setNewWhitelistAddress(e.target.value)}
                      className="flex-1"
                    />
                    <Input
                      placeholder="Label"
                      value={newWhitelistLabel}
                      onChange={(e) => setNewWhitelistLabel(e.target.value)}
                      className="w-32"
                    />
                    <Button onClick={addWhitelistAddress} disabled={!newWhitelistAddress || !newWhitelistLabel}>
                      <Plus className="w-4 h-4" />
                    </Button>
                  </div>

<div className="space-y-2 max-h-48 overflow-y-auto">
                    {settings.whitelistedAddresses.length === 0 ? (
                      <p className="text-sm text-muted-foreground text-center py-4">
                        No whitelisted addresses yet. Add addresses to enable whitelist protection.
                      </p>
                    ) : (
                      settings.whitelistedAddresses.map((wa) => (
                        <div
                          key={wa.address}
                          className="flex items-center justify-between p-3 bg-muted rounded-lg"
                        >
                          <div>
                            <p className="font-medium">{wa.label}</p>
                            <p className="text-xs font-mono text-muted-foreground">
                              {wa.address.slice(0, 10)}...{wa.address.slice(-8)}
                            </p>
                          </div>
                          <Button
                            variant="ghost"
                            size="sm"
                            onClick={() => removeWhitelistAddress(wa.address)}
                          >
                            <Trash2 className="w-4 h-4 text-red-500" />
                          </Button>
                        </div>
                      ))
                    )}
                  </div>
                </>
              )}
            </CardContent>
          </Card>
        </TabsContent>

{/* Devices Tab */}
        <TabsContent value="devices" className="space-y-4">
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <Monitor className="w-5 h-5" />
                Trusted Devices
              </CardTitle>
              <CardDescription>
                Manage devices that have accessed your wallet
              </CardDescription>
            </CardHeader>
            <CardContent>
              {trustedDevices.length === 0 ? (
                <div className="text-center py-8">
                  <Smartphone className="w-12 h-12 mx-auto text-muted-foreground mb-2" />
                  <p className="text-muted-foreground">No devices recorded yet</p>
                </div>
              ) : (
                <div className="space-y-3">
                  {trustedDevices.map((device) => (
                    <div
                      key={device.id}
                      className="flex items-center justify-between p-4 border rounded-lg"
                    >
                      <div className="flex items-center gap-3">
                        {device.device_type === "mobile" ? (
                          <Smartphone className="w-8 h-8 text-primary" />
                        ) : (
                          <Monitor className="w-8 h-8 text-primary" />
                        )}
                        <div>
                          <p className="font-medium">{device.device_name || "Unknown Device"}</p>
                          <p className="text-sm text-muted-foreground">
                            {device.browser} on {device.os}
                          </p>
                          <p className="text-xs text-muted-foreground">
                            Last active: {new Date(device.last_active).toLocaleDateString()}
                          </p>
                        </div>
                      </div>
                      <div className="flex items-center gap-2">
                        {device.is_trusted && (
                          <Badge variant="outline" className="text-green-500 border-green-500">
                            Trusted
                          </Badge>
                        )}
                        <Button
                          variant="ghost"
                          size="sm"
                          onClick={() => removeDevice(device.id)}
                        >
                          <Trash2 className="w-4 h-4 text-red-500" />
                        </Button>
                      </div>
                    </div>
                  ))}
                </div>
              )}
            </CardContent>
          </Card>
        </TabsContent>

{/* Activity Tab */}
        <TabsContent value="activity" className="space-y-4">
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <Activity className="w-5 h-5" />
                Recent Security Activity
              </CardTitle>
              <CardDescription>
                View recent security events and login history
              </CardDescription>
            </CardHeader>
            <CardContent>
              {recentEvents.length === 0 ? (
                <div className="text-center py-8">
                  <Activity className="w-12 h-12 mx-auto text-muted-foreground mb-2" />
                  <p className="text-muted-foreground">No recent security events</p>
                </div>
              ) : (
                <div className="space-y-3">
                  {recentEvents.map((event) => (
                    <div
                      key={event.id}
                      className="flex items-center justify-between p-3 border rounded-lg"
                    >
                      <div className="flex items-center gap-3">
                        {getEventIcon(event.event_type)}
                        <div>
                          <p className="font-medium capitalize">
                            {event.event_type.replace(/_/g, " ")}
                          </p>
                          <p className="text-xs text-muted-foreground">
                            {new Date(event.created_at).toLocaleString()}
                          </p>
                        </div>
                      </div>
                      <Badge
                        variant={
                          event.severity === "critical" ? "destructive" :
                          event.severity === "high" ? "destructive" :
                          event.severity === "medium" ? "secondary" : "outline"
                        }
                      >
                        {event.severity}
                      </Badge>
                    </div>
                  ))}
                </div>
              )}
            </CardContent>
          </Card>
        </TabsContent>
      </Tabs>
    </div>
  )
}
[V0_FILE]typescript:file="app/api/security/route.ts" isMerged="true"
"use server"

import { createClient } from "@supabase/supabase-js"
import { NextResponse } from "next/server"
import crypto from "crypto"

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
)

// Helper to hash device fingerprint
function hashFingerprint(fingerprint: string): string {
  return crypto.createHash("sha256").update(fingerprint).digest("hex")
}

export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url)
    const userId = searchParams.get("userId")
    const action = searchParams.get("action")

if (!userId) {
      return NextResponse.json({ error: "User ID required" }, { status: 400 })
    }

switch (action) {
      case "settings": {
        const { data, error } = await supabase
          .from("security_settings")
          .select("*")
          .eq("user_id", userId)
          .single()

if (error && error.code !== "PGRST116") {
          throw error
        }

// Return default settings if none exist
        if (!data) {
          return NextResponse.json({
            two_factor_enabled: false,
            biometric_enabled: false,
            transaction_signing: true,
            auto_lock_timeout: 5,
            withdrawal_whitelist_only: false,
            login_notifications: true,
            transaction_notifications: true,
            security_alerts: true,
          })
        }

return NextResponse.json(data)
      }

case "events": {
        const limit = parseInt(searchParams.get("limit") || "50")
        const { data, error } = await supabase
          .from("security_events")
          .select("*")
          .eq("user_id", userId)
          .order("created_at", { ascending: false })
          .limit(limit)

if (error) throw error
        return NextResponse.json(data || [])
      }

case "devices": {
        const { data, error } = await supabase
          .from("trusted_devices")
          .select("*")
          .eq("user_id", userId)
          .order("last_used", { ascending: false })

if (error) throw error
        return NextResponse.json(data || [])
      }

case "sessions": {
        const { data, error } = await supabase
          .from("active_sessions")
          .select("*")
          .eq("user_id", userId)
          .eq("is_active", true)
          .order("last_activity", { ascending: false })

if (error) throw error
        return NextResponse.json(data || [])
      }

default:
        return NextResponse.json({ error: "Invalid action" }, { status: 400 })
    }
  } catch (error) {
    console.error("[Security API] GET error:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}

export async function POST(request: Request) {
  try {
    const body = await request.json()
    const { action, userId, ...data } = body

if (!userId) {
      return NextResponse.json({ error: "User ID required" }, { status: 400 })
    }

switch (action) {
      case "updateSettings": {
        const { error } = await supabase
          .from("security_settings")
          .upsert({
            user_id: userId,
            ...data.settings,
            updated_at: new Date().toISOString(),
          })

if (error) throw error

// Log security event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "settings_changed",
          description: "Security settings updated",
          ip_address: data.ipAddress || "unknown",
          user_agent: data.userAgent || "unknown",
          risk_level: "low",
        })

return NextResponse.json({ success: true })
      }

case "logEvent": {
        const { error } = await supabase.from("security_events").insert({
          user_id: userId,
          event_type: data.eventType,
          description: data.description,
          ip_address: data.ipAddress || "unknown",
          user_agent: data.userAgent || "unknown",
          device_fingerprint: data.fingerprint ? hashFingerprint(data.fingerprint) : null,
          location: data.location || null,
          risk_level: data.riskLevel || "low",
          metadata: data.metadata || null,
        })

if (error) throw error
        return NextResponse.json({ success: true })
      }

case "trustDevice": {
        const fingerprintHash = hashFingerprint(data.fingerprint)
        
        const { error } = await supabase.from("trusted_devices").upsert({
          user_id: userId,
          device_fingerprint: fingerprintHash,
          device_name: data.deviceName,
          device_type: data.deviceType,
          browser: data.browser,
          os: data.os,
          last_used: new Date().toISOString(),
          is_trusted: true,
        })

if (error) throw error

// Log security event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "device_trusted",
          description: `Device "${data.deviceName}" added to trusted devices`,
          device_fingerprint: fingerprintHash,
          risk_level: "medium",
        })

return NextResponse.json({ success: true })
      }

case "revokeDevice": {
        const { error } = await supabase
          .from("trusted_devices")
          .delete()
          .eq("user_id", userId)
          .eq("id", data.deviceId)

if (error) throw error

// Log security event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "device_revoked",
          description: "Trusted device removed",
          risk_level: "medium",
        })

return NextResponse.json({ success: true })
      }

case "createSession": {
        const sessionToken = crypto.randomBytes(32).toString("hex")
        const fingerprintHash = data.fingerprint ? hashFingerprint(data.fingerprint) : null

const { error } = await supabase.from("active_sessions").insert({
          user_id: userId,
          session_token: sessionToken,
          device_fingerprint: fingerprintHash,
          ip_address: data.ipAddress || "unknown",
          user_agent: data.userAgent || "unknown",
          location: data.location || null,
          is_active: true,
          expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(), // 7 days
        })

if (error) throw error

// Log login event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "login",
          description: "New session created",
          ip_address: data.ipAddress || "unknown",
          user_agent: data.userAgent || "unknown",
          device_fingerprint: fingerprintHash,
          location: data.location || null,
          risk_level: "low",
        })

return NextResponse.json({ success: true, sessionToken })
      }

case "terminateSession": {
        const { error } = await supabase
          .from("active_sessions")
          .update({ is_active: false })
          .eq("user_id", userId)
          .eq("id", data.sessionId)

if (error) throw error

// Log security event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "session_terminated",
          description: "Session manually terminated",
          risk_level: "low",
        })

return NextResponse.json({ success: true })
      }

case "terminateAllSessions": {
        const { error } = await supabase
          .from("active_sessions")
          .update({ is_active: false })
          .eq("user_id", userId)
          .neq("id", data.currentSessionId || "")

if (error) throw error

// Log security event
        await supabase.from("security_events").insert({
          user_id: userId,
          event_type: "all_sessions_terminated",
          description: "All other sessions terminated",
          risk_level: "high",
        })

return NextResponse.json({ success: true })
      }

case "checkDeviceTrust": {
        const fingerprintHash = hashFingerprint(data.fingerprint)
        
        const { data: device, error } = await supabase
          .from("trusted_devices")
          .select("*")
          .eq("user_id", userId)
          .eq("device_fingerprint", fingerprintHash)
          .eq("is_trusted", true)
          .single()

if (error && error.code !== "PGRST116") throw error

return NextResponse.json({ 
          isTrusted: !!device,
          device: device || null 
        })
      }

default:
        return NextResponse.json({ error: "Invalid action" }, { status: 400 })
    }
  } catch (error) {
    console.error("[Security API] POST error:", error)
    return NextResponse.json({ error: "Internal server error" }, { status: 500 })
  }
}
[V0_FILE]typescriptreact:file="components/transaction-confirmation.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle, CardDescription, CardFooter } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Badge } from "@/components/ui/badge"
import { AlertTriangle, Shield, CheckCircle2, X, Fingerprint, Lock, Eye, EyeOff, Loader2 } from "lucide-react"
import { cn } from "@/lib/utils"

interface TransactionDetails {
  type: "send" | "swap" | "approve" | "contract"
  to: string
  amount: string
  token: string
  gasEstimate?: string
  gasFee?: string
  network: string
  contractAddress?: string
  contractMethod?: string
  warnings?: string[]
}

interface TransactionConfirmationProps {
  transaction: TransactionDetails
  onConfirm: () => void
  onCancel: () => void
  requirePassword?: boolean
  requireBiometric?: boolean
  isProcessing?: boolean
}

export function TransactionConfirmation({
  transaction,
  onConfirm,
  onCancel,
  requirePassword = true,
  requireBiometric = false,
  isProcessing = false,
}: TransactionConfirmationProps) {
  const [password, setPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [passwordVerified, setPasswordVerified] = useState(false)
  const [biometricVerified, setBiometricVerified] = useState(false)
  const [verifying, setVerifying] = useState(false)
  const [error, setError] = useState("")
  const [countdown, setCountdown] = useState(5)
  const [canConfirm, setCanConfirm] = useState(false)

// Countdown before allowing confirmation (security measure)
  useEffect(() => {
    if (countdown > 0) {
      const timer = setTimeout(() => setCountdown(countdown - 1), 1000)
      return () => clearTimeout(timer)
    } else {
      setCanConfirm(true)
    }
  }, [countdown])

const verifyPassword = async () => {
    if (!password) {
      setError("Please enter your password")
      return
    }

setVerifying(true)
    setError("")

try {
      // Get wallet session and verify password
      const walletSession = sessionStorage.getItem("linkficrypto_wallet_session")
      if (!walletSession) {
        setError("Session expired. Please sign in again.")
        return
      }

const { address } = JSON.parse(walletSession)
      
      // Verify against stored encrypted wallet
      const encryptedWallet = localStorage.getItem(`linkfi_wallet_${address.toLowerCase()}`)
      if (!encryptedWallet) {
        setError("Wallet not found")
        return
      }

// Try to decrypt with provided password
      const { ethers } = await import("ethers")
      try {
        await ethers.Wallet.fromEncryptedJson(encryptedWallet, password)
        setPasswordVerified(true)
        setError("")
      } catch {
        setError("Incorrect password")
      }
    } catch (err) {
      setError("Verification failed")
    } finally {
      setVerifying(false)
    }
  }

const handleBiometric = async () => {
    try {
      // Check if WebAuthn is available
      if (!window.PublicKeyCredential) {
        setError("Biometric authentication not supported")
        return
      }

// In a real implementation, this would use WebAuthn
      // For now, simulate biometric verification
      setVerifying(true)
      
      // Simulate biometric check
      await new Promise((resolve) => setTimeout(resolve, 1500))
      setBiometricVerified(true)
      setError("")
    } catch (err) {
      setError("Biometric verification failed")
    } finally {
      setVerifying(false)
    }
  }

const handleConfirm = () => {
    if (requirePassword && !passwordVerified) {
      setError("Please verify your password first")
      return
    }
    if (requireBiometric && !biometricVerified) {
      setError("Please complete biometric verification")
      return
    }
    if (!canConfirm) {
      return
    }
    onConfirm()
  }

const isHighRisk = transaction.warnings && transaction.warnings.length > 0

const formatAddress = (addr: string) => {
    if (!addr) return ""
    return `${addr.slice(0, 8)}...${addr.slice(-6)}`
  }

return (
    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/60 backdrop-blur-sm p-4">
      <Card className="w-full max-w-md border-2 border-primary/20 shadow-2xl">
        <CardHeader className="space-y-1 pb-4">
          <div className="flex items-center justify-between">
            <div className="flex items-center gap-2">
              <Shield className="h-5 w-5 text-primary" />
              <CardTitle className="text-lg">Confirm Transaction</CardTitle>
            </div>
            <Button variant="ghost" size="icon" onClick={onCancel} disabled={isProcessing}>
              <X className="h-4 w-4" />
            </Button>
          </div>
          <CardDescription>Review and verify this transaction before signing</CardDescription>
        </CardHeader>

<CardContent className="space-y-4">
          {/* Transaction Type Badge */}
          <div className="flex items-center justify-between">
            <span className="text-sm text-muted-foreground">Transaction Type</span>
            <Badge variant={isHighRisk ? "destructive" : "secondary"} className="uppercase">
              {transaction.type}
            </Badge>
          </div>

{/* Warnings */}
          {isHighRisk && (
            <div className="bg-destructive/10 border border-destructive/30 rounded-lg p-3 space-y-2">
              <div className="flex items-center gap-2 text-destructive">
                <AlertTriangle className="h-4 w-4" />
                <span className="font-medium text-sm">Security Warnings</span>
              </div>
              <ul className="text-xs text-destructive/90 space-y-1 list-disc list-inside">
                {transaction.warnings?.map((warning, i) => (
                  <li key={i}>{warning}</li>
                ))}
              </ul>
            </div>
          )}

{/* Transaction Details */}
          <div className="bg-muted/50 rounded-lg p-4 space-y-3">
            <div className="flex justify-between items-center">
              <span className="text-sm text-muted-foreground">To</span>
              <span className="font-mono text-sm">{formatAddress(transaction.to)}</span>
            </div>
            <div className="flex justify-between items-center">
              <span className="text-sm text-muted-foreground">Amount</span>
              <span className="font-semibold">
                {transaction.amount} {transaction.token}
              </span>
            </div>
            <div className="flex justify-between items-center">
              <span className="text-sm text-muted-foreground">Network</span>
              <span className="text-sm">{transaction.network}</span>
            </div>
            {transaction.gasFee && (
              <div className="flex justify-between items-center pt-2 border-t border-border">
                <span className="text-sm text-muted-foreground">Est. Gas Fee</span>
                <span className="text-sm">{transaction.gasFee}</span>
              </div>
            )}
            {transaction.contractMethod && (
              <div className="flex justify-between items-center">
                <span className="text-sm text-muted-foreground">Method</span>
                <span className="font-mono text-xs bg-muted px-2 py-1 rounded">
                  {transaction.contractMethod}
                </span>
              </div>
            )}
          </div>

{/* Password Verification */}
          {requirePassword && !passwordVerified && (
            <div className="space-y-3">
              <Label htmlFor="tx-password" className="text-sm font-medium flex items-center gap-2">
                <Lock className="h-4 w-4" />
                Enter password to sign
              </Label>
              <div className="relative">
                <Input
                  id="tx-password"
                  type={showPassword ? "text" : "password"}
                  placeholder="Enter your wallet password"
                  value={password}
                  onChange={(e) => setPassword(e.target.value)}
                  onKeyDown={(e) => e.key === "Enter" && verifyPassword()}
                  className="pr-10"
                />
                <button
                  type="button"
                  onClick={() => setShowPassword(!showPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showPassword ? <EyeOff className="h-4 w-4" /> : <Eye className="h-4 w-4" />}
                </button>
              </div>
              <Button
                onClick={verifyPassword}
                disabled={verifying || !password}
                className="w-full"
                variant="outline"
              >
                {verifying ? (
                  <>
                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
                    Verifying...
                  </>
                ) : (
                  "Verify Password"
                )}
              </Button>
            </div>
          )}

{/* Password Verified */}
          {passwordVerified && (
            <div className="flex items-center gap-2 text-green-600 bg-green-50 dark:bg-green-950/30 px-3 py-2 rounded-lg">
              <CheckCircle2 className="h-4 w-4" />
              <span className="text-sm font-medium">Password verified</span>
            </div>
          )}

{/* Biometric Verification */}
          {requireBiometric && passwordVerified && !biometricVerified && (
            <div className="space-y-3">
              <Label className="text-sm font-medium flex items-center gap-2">
                <Fingerprint className="h-4 w-4" />
                Biometric verification required
              </Label>
              <Button
                onClick={handleBiometric}
                disabled={verifying}
                className="w-full"
                variant="outline"
              >
                {verifying ? (
                  <>
                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
                    Scanning...
                  </>
                ) : (
                  <>
                    <Fingerprint className="h-4 w-4 mr-2" />
                    Use Biometrics
                  </>
                )}
              </Button>
            </div>
          )}

{/* Biometric Verified */}
          {biometricVerified && (
            <div className="flex items-center gap-2 text-green-600 bg-green-50 dark:bg-green-950/30 px-3 py-2 rounded-lg">
              <CheckCircle2 className="h-4 w-4" />
              <span className="text-sm font-medium">Biometric verified</span>
            </div>
          )}

{/* Error Message */}
          {error && (
            <div className="flex items-center gap-2 text-destructive bg-destructive/10 px-3 py-2 rounded-lg">
              <AlertTriangle className="h-4 w-4" />
              <span className="text-sm">{error}</span>
            </div>
          )}
        </CardContent>

<CardFooter className="flex gap-3 pt-4">
          <Button variant="outline" onClick={onCancel} disabled={isProcessing} className="flex-1">
            Cancel
          </Button>
          <Button
            onClick={handleConfirm}
            disabled={
              isProcessing ||
              !canConfirm ||
              (requirePassword && !passwordVerified) ||
              (requireBiometric && !biometricVerified)
            }
            className={cn(
              "flex-1",
              isHighRisk && "bg-destructive hover:bg-destructive/90"
            )}
          >
            {isProcessing ? (
              <>
                <Loader2 className="h-4 w-4 mr-2 animate-spin" />
                Processing...
              </>
            ) : !canConfirm ? (
              `Wait ${countdown}s`
            ) : (
              "Sign & Confirm"
            )}
          </Button>
        </CardFooter>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/auto-lock.tsx" isMerged="true"
"use client"

import { useState, useEffect, useCallback, useRef } from "react"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Lock, Eye, EyeOff, Loader2, Shield } from "lucide-react"
import { cn } from "@/lib/utils"

interface AutoLockProviderProps {
  children: React.ReactNode
  timeoutMinutes?: number
  onLock?: () => void
  onUnlock?: () => void
  enabled?: boolean
}

export function AutoLockProvider({
  children,
  timeoutMinutes = 5,
  onLock,
  onUnlock,
  enabled = true,
}: AutoLockProviderProps) {
  const [isLocked, setIsLocked] = useState(false)
  const [password, setPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [error, setError] = useState("")
  const [unlocking, setUnlocking] = useState(false)
  const [lastActivity, setLastActivity] = useState(Date.now())
  const timeoutRef = useRef<NodeJS.Timeout | null>(null)

// Activity tracking
  const updateActivity = useCallback(() => {
    setLastActivity(Date.now())
  }, [])

// Check for inactivity and lock
  useEffect(() => {
    if (!enabled || isLocked) return

const checkInactivity = () => {
      const now = Date.now()
      const inactiveTime = now - lastActivity
      const timeoutMs = timeoutMinutes * 60 * 1000

if (inactiveTime >= timeoutMs) {
        handleLock()
      }
    }

// Check every 30 seconds
    timeoutRef.current = setInterval(checkInactivity, 30000)

// Activity listeners
    const events = ["mousedown", "mousemove", "keydown", "scroll", "touchstart", "click"]
    events.forEach((event) => {
      document.addEventListener(event, updateActivity, { passive: true })
    })

return () => {
      if (timeoutRef.current) {
        clearInterval(timeoutRef.current)
      }
      events.forEach((event) => {
        document.removeEventListener(event, updateActivity)
      })
    }
  }, [enabled, isLocked, lastActivity, timeoutMinutes, updateActivity])

// Check if wallet session exists on mount
  useEffect(() => {
    if (typeof window === "undefined") return

const checkSession = () => {
      const session = sessionStorage.getItem("linkficrypto_wallet_session")
      if (!session && !isLocked) {
        // No session, but we might be on initial load
        return
      }
    }

checkSession()

// Also check when tab becomes visible again
    const handleVisibilityChange = () => {
      if (document.visibilityState === "visible") {
        // Check if we've been away too long
        const now = Date.now()
        const inactiveTime = now - lastActivity
        const timeoutMs = timeoutMinutes * 60 * 1000

if (inactiveTime >= timeoutMs && enabled) {
          handleLock()
        }
      }
    }

document.addEventListener("visibilitychange", handleVisibilityChange)
    return () => {
      document.removeEventListener("visibilitychange", handleVisibilityChange)
    }
  }, [enabled, timeoutMinutes, lastActivity, isLocked])

const handleLock = () => {
    // Clear sensitive session data
    sessionStorage.removeItem("unlockedWallet")
    
    setIsLocked(true)
    onLock?.()
  }

const handleUnlock = async () => {
    if (!password) {
      setError("Please enter your password")
      return
    }

setUnlocking(true)
    setError("")

try {
      // Get wallet address from session
      const session = sessionStorage.getItem("linkficrypto_wallet_session")
      if (!session) {
        setError("Session expired. Please sign in again.")
        // Redirect to login
        window.location.reload()
        return
      }

const { address } = JSON.parse(session)

// Get encrypted wallet
      const encryptedWallet = localStorage.getItem(`linkfi_wallet_${address.toLowerCase()}`)
      if (!encryptedWallet) {
        setError("Wallet not found")
        return
      }

// Try to decrypt
      const { ethers } = await import("ethers")
      try {
        const wallet = await ethers.Wallet.fromEncryptedJson(encryptedWallet, password)
        
        // Store unlocked wallet in session
        sessionStorage.setItem(
          "unlockedWallet",
          JSON.stringify({
            address: wallet.address,
            privateKey: wallet.privateKey,
          })
        )

setIsLocked(false)
        setPassword("")
        setLastActivity(Date.now())
        onUnlock?.()
      } catch {
        setError("Incorrect password")
      }
    } catch (err) {
      setError("Failed to unlock wallet")
      console.error(err)
    } finally {
      setUnlocking(false)
    }
  }

if (isLocked) {
    return (
      <div className="fixed inset-0 z-50 flex items-center justify-center bg-background">
        <Card className="w-full max-w-md mx-4 border-2 shadow-2xl">
          <CardHeader className="text-center space-y-2">
            <div className="mx-auto p-4 bg-primary/10 rounded-full w-fit">
              <Lock className="h-8 w-8 text-primary" />
            </div>
            <CardTitle className="text-2xl">Wallet Locked</CardTitle>
            <CardDescription>
              Your wallet was locked due to inactivity. Enter your password to unlock.
            </CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="unlock-password">Password</Label>
              <div className="relative">
                <Input
                  id="unlock-password"
                  type={showPassword ? "text" : "password"}
                  placeholder="Enter your wallet password"
                  value={password}
                  onChange={(e) => setPassword(e.target.value)}
                  onKeyDown={(e) => e.key === "Enter" && handleUnlock()}
                  className="pr-10"
                  autoFocus
                />
                <button
                  type="button"
                  onClick={() => setShowPassword(!showPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showPassword ? <EyeOff className="h-4 w-4" /> : <Eye className="h-4 w-4" />}
                </button>
              </div>
            </div>

{error && (
              <p className="text-sm text-destructive text-center">{error}</p>
            )}

<Button
              onClick={handleUnlock}
              disabled={unlocking || !password}
              className="w-full"
              size="lg"
            >
              {unlocking ? (
                <>
                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
                  Unlocking...
                </>
              ) : (
                <>
                  <Lock className="h-4 w-4 mr-2" />
                  Unlock Wallet
                </>
              )}
            </Button>

<div className="flex items-center justify-center gap-2 text-xs text-muted-foreground pt-2">
              <Shield className="h-3 w-3" />
              <span>Auto-lock after {timeoutMinutes} minutes of inactivity</span>
            </div>
          </CardContent>
        </Card>
      </div>
    )
  }

return <>{children}</>
}

// Hook to manually trigger lock
export function useLockWallet() {
  const lockWallet = () => {
    // Clear sensitive data
    sessionStorage.removeItem("unlockedWallet")
    
    // Dispatch custom event that AutoLockProvider can listen to
    window.dispatchEvent(new CustomEvent("wallet-lock-requested"))
  }

return { lockWallet }
}
[V0_FILE]typescriptreact:file="app/settings/security/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { createClient } from "@/lib/supabase/client"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Label } from "@/components/ui/label"
import { Input } from "@/components/ui/input"
import { Switch } from "@/components/ui/switch"
import { Badge } from "@/components/ui/badge"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { 
  Shield, Check, X, Eye, EyeOff, AlertTriangle, Lock, Fingerprint, 
  Smartphone, Monitor, Globe, Clock, Bell, ShieldCheck, ShieldAlert,
  Key, History, Trash2, LogOut, RefreshCw, ChevronRight, Loader2
} from "lucide-react"
import { MFASetup } from "@/components/mfa-setup"
import { isMFAEnabled, disableMFA, getMFASettings } from "@/lib/mfa"
import { validatePasswordStrength } from "@/lib/password-security"
import { useRouter } from "next/navigation"
import Link from "next/link"
import { encryptWallet, decryptWallet } from "@/lib/wallet-generator"

interface SecuritySettings {
  two_factor_enabled: boolean
  biometric_enabled: boolean
  transaction_signing: boolean
  auto_lock_timeout: number
  withdrawal_whitelist_only: boolean
  login_notifications: boolean
  transaction_notifications: boolean
  security_alerts: boolean
}

interface SecurityEvent {
  id: string
  event_type: string
  description: string
  ip_address: string
  location: string
  created_at: string
  risk_level: string
}

interface TrustedDevice {
  id: string
  device_name: string
  device_type: string
  browser: string
  os: string
  last_used: string
  is_current: boolean
}

interface ActiveSession {
  id: string
  ip_address: string
  location: string
  last_activity: string
  is_current: boolean
}

export default function SecuritySettingsPage() {
  const [user, setUser] = useState<any>(null)
  const [loading, setLoading] = useState(true)
  const [mfaEnabled, setMfaEnabled] = useState(false)
  const [showMFASetup, setShowMFASetup] = useState(false)
  const [showPasswordChange, setShowPasswordChange] = useState(false)
  const [currentPassword, setCurrentPassword] = useState("")
  const [newPassword, setNewPassword] = useState("")
  const [confirmPassword, setConfirmPassword] = useState("")
  const [showCurrentPassword, setShowCurrentPassword] = useState(false)
  const [showNewPassword, setShowNewPassword] = useState(false)
  const [error, setError] = useState("")
  const [success, setSuccess] = useState("")
  const [backupCodesCount, setBackupCodesCount] = useState(0)
  const [showWalletExport, setShowWalletExport] = useState(false)
  const [exportPassword, setExportPassword] = useState("")
  const [showExportPassword, setShowExportPassword] = useState(false)
  const [exportedPrivateKey, setExportedPrivateKey] = useState("")
  const [walletAddress, setWalletAddress] = useState("")
  const [exportLoading, setExportLoading] = useState(false)
  const [exportError, setExportError] = useState("")
  const [activeTab, setActiveTab] = useState("overview")
  const [securitySettings, setSecuritySettings] = useState<SecuritySettings>({
    two_factor_enabled: false,
    biometric_enabled: false,
    transaction_signing: true,
    auto_lock_timeout: 5,
    withdrawal_whitelist_only: false,
    login_notifications: true,
    transaction_notifications: true,
    security_alerts: true,
  })
  const [securityEvents, setSecurityEvents] = useState<SecurityEvent[]>([])
  const [trustedDevices, setTrustedDevices] = useState<TrustedDevice[]>([])
  const [activeSessions, setActiveSessions] = useState<ActiveSession[]>([])
  const [savingSettings, setSavingSettings] = useState(false)
  const [securityScore, setSecurityScore] = useState(0)
  const router = useRouter()
  const supabase = createClient()

useEffect(() => {
    checkAuth()
  }, [])

const checkAuth = async () => {
    const {
      data: { user: authUser },
    } = await supabase.auth.getUser()

if (!authUser) {
      router.push("/auth/login")
      return
    }

setUser(authUser)

const enabled = await isMFAEnabled(authUser.id)
    setMfaEnabled(enabled)

if (enabled) {
      const settings = await getMFASettings(authUser.id)
      setBackupCodesCount(settings?.backup_codes?.length || 0)
    }

// Fetch security settings
    await fetchSecurityData(authUser.id)

setLoading(false)
  }

const fetchSecurityData = async (userId: string) => {
    try {
      // Fetch settings
      const settingsRes = await fetch(`/api/security?userId=${userId}&action=settings`)
      if (settingsRes.ok) {
        const data = await settingsRes.json()
        setSecuritySettings(data)
      }

// Fetch events
      const eventsRes = await fetch(`/api/security?userId=${userId}&action=events&limit=20`)
      if (eventsRes.ok) {
        const data = await eventsRes.json()
        setSecurityEvents(data)
      }

// Fetch devices
      const devicesRes = await fetch(`/api/security?userId=${userId}&action=devices`)
      if (devicesRes.ok) {
        const data = await devicesRes.json()
        setTrustedDevices(data)
      }

// Fetch sessions
      const sessionsRes = await fetch(`/api/security?userId=${userId}&action=sessions`)
      if (sessionsRes.ok) {
        const data = await sessionsRes.json()
        setActiveSessions(data)
      }

// Calculate security score
      calculateSecurityScore()
    } catch (err) {
      console.error("Error fetching security data:", err)
    }
  }

const calculateSecurityScore = () => {
    let score = 0
    
    // Password strength (assumed to be strong if user is logged in)
    score += 20
    
    // MFA enabled
    if (mfaEnabled || securitySettings.two_factor_enabled) score += 25
    
    // Transaction signing
    if (securitySettings.transaction_signing) score += 15
    
    // Auto-lock enabled
    if (securitySettings.auto_lock_timeout > 0) score += 10
    
    // Notifications enabled
    if (securitySettings.login_notifications) score += 10
    if (securitySettings.transaction_notifications) score += 10
    if (securitySettings.security_alerts) score += 10
    
    setSecurityScore(score)
  }

const updateSecuritySetting = async (key: keyof SecuritySettings, value: any) => {
    if (!user) return
    
    const newSettings = { ...securitySettings, [key]: value }
    setSecuritySettings(newSettings)
    setSavingSettings(true)

try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "updateSettings",
          userId: user.id,
          settings: newSettings,
        }),
      })
      calculateSecurityScore()
    } catch (err) {
      console.error("Error updating settings:", err)
    } finally {
      setSavingSettings(false)
    }
  }

const revokeDevice = async (deviceId: string) => {
    if (!user) return
    
    try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "revokeDevice",
          userId: user.id,
          deviceId,
        }),
      })
      setTrustedDevices(prev => prev.filter(d => d.id !== deviceId))
    } catch (err) {
      console.error("Error revoking device:", err)
    }
  }

const terminateSession = async (sessionId: string) => {
    if (!user) return
    
    try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "terminateSession",
          userId: user.id,
          sessionId,
        }),
      })
      setActiveSessions(prev => prev.filter(s => s.id !== sessionId))
    } catch (err) {
      console.error("Error terminating session:", err)
    }
  }

const terminateAllSessions = async () => {
    if (!user) return
    
    const confirmed = confirm("This will sign you out from all other devices. Continue?")
    if (!confirmed) return

try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "terminateAllSessions",
          userId: user.id,
        }),
      })
      setActiveSessions(prev => prev.filter(s => s.is_current))
      setSuccess("All other sessions have been terminated")
    } catch (err) {
      console.error("Error terminating sessions:", err)
    }
  }

useEffect(() => {
    calculateSecurityScore()
  }, [mfaEnabled, securitySettings])

const handleDisableMFA = async () => {
    if (!user) return

const confirmed = confirm(
      "Are you sure you want to disable two-factor authentication? This will make your account less secure.",
    )
    if (!confirmed) return

setLoading(true)
    const success = await disableMFA(user.id)

if (success) {
      setMfaEnabled(false)
      setSuccess("Two-factor authentication has been disabled")
    } else {
      setError("Failed to disable MFA. Please try again.")
    }

setLoading(false)
  }

const handlePasswordChange = async () => {
    setError("")
    setSuccess("")

if (newPassword !== confirmPassword) {
      setError("New passwords do not match")
      return
    }

const passwordStrength = validatePasswordStrength(newPassword)
    if (!passwordStrength.isSecure) {
      setError("New password does not meet security requirements")
      return
    }

setLoading(true)

try {
      // Re-authenticate user with current password
      const { error: signInError } = await supabase.auth.signInWithPassword({
        email: user.email,
        password: currentPassword,
      })

if (signInError) {
        setError("Current password is incorrect")
        setLoading(false)
        return
      }

// Check if user has a wallet
      const { data: profile } = await supabase
        .from("profiles")
        .select("encrypted_wallet, has_builtin_wallet")
        .eq("id", user.id)
        .single()

if (profile?.encrypted_wallet && profile?.has_builtin_wallet) {
        // Decrypt wallet with current password
        const decryptedWallet = await decryptWallet(profile.encrypted_wallet, currentPassword)

// Re-encrypt wallet with new password
        const reEncryptedWallet = await encryptWallet(decryptedWallet, newPassword)

// Update wallet in database
        const { error: walletUpdateError } = await supabase
          .from("profiles")
          .update({ encrypted_wallet: reEncryptedWallet })
          .eq("id", user.id)

if (walletUpdateError) {
          setError("Failed to update wallet encryption. Please try again.")
          setLoading(false)
          return
        }

// Update localStorage
        localStorage.setItem("linkficrypto_wallet", reEncryptedWallet)
      }

// Update password in Supabase Auth
      const { error: updateError } = await supabase.auth.updateUser({
        password: newPassword,
      })

if (updateError) {
        setError(updateError.message)
        setLoading(false)
        return
      }

sessionStorage.removeItem("linkficrypto_wallet_session")
      sessionStorage.removeItem("linkficrypto_wallet_unlocked")

setSuccess("Password updated successfully. Redirecting to login...")
      setCurrentPassword("")
      setNewPassword("")
      setConfirmPassword("")
      setShowPasswordChange(false)

// Sign out and redirect to login
      setTimeout(async () => {
        await supabase.auth.signOut()
        router.push("/auth/login?message=password-changed")
      }, 2000)
    } catch (err: any) {
      setError(err.message || "Failed to update password. Please try again.")
      setLoading(false)
    }
  }

const handleExportWallet = async () => {
    if (!exportPassword) {
      setExportError("Please enter your account password")
      return
    }

setExportLoading(true)
    setExportError("")
    setExportedPrivateKey("")

try {
      // Get profile with encrypted wallet
      const { data: profile, error: profileError } = await supabase
        .from("profiles")
        .select("encrypted_wallet, builtin_wallet_address, username")
        .eq("id", user.id)
        .single()

if (profileError || !profile) {
        setExportError("Failed to load your wallet. Please try again.")
        setExportLoading(false)
        return
      }

if (!profile.encrypted_wallet) {
        setExportError("No wallet found for your account.")
        setExportLoading(false)
        return
      }

// Decrypt wallet using the password
      const encryptedWalletData =
        typeof profile.encrypted_wallet === "string"
          ? profile.encrypted_wallet
          : JSON.stringify(profile.encrypted_wallet)

const decryptedWallet = await decryptWallet(encryptedWalletData, exportPassword)

// Extract private key
      setExportedPrivateKey(decryptedWallet.privateKey)
      setWalletAddress(profile.builtin_wallet_address)
      setSuccess("Wallet decrypted successfully! Your private key is displayed below.")
    } catch (err: any) {
      console.error("[v0] Wallet export error:", err)
      if (err.message?.includes("password") || err.message?.includes("decrypt")) {
        setExportError("Incorrect password. Please enter your account password.")
      } else {
        setExportError("Failed to decrypt wallet: " + (err.message || "Unknown error"))
      }
    } finally {
      setExportLoading(false)
    }
  }

const copyToClipboard = (text: string) => {
    navigator.clipboard.writeText(text)
    setSuccess("Copied to clipboard!")
    setTimeout(() => setSuccess(""), 2000)
  }

const resetExportForm = () => {
    setShowWalletExport(false)
    setExportPassword("")
    setExportedPrivateKey("")
    setWalletAddress("")
    setExportError("")
    setShowExportPassword(false)
  }

const passwordStrength = validatePasswordStrength(newPassword)

if (loading && !user) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-black">
        <div className="text-center">
          <div className="w-12 h-12 border-4 border-primary border-t-transparent rounded-full animate-spin mx-auto mb-4"></div>
          <p className="text-muted-foreground">Loading security settings...</p>
        </div>
      </div>
    )
  }

const getScoreColor = (score: number) => {
    if (score >= 80) return "text-green-500"
    if (score >= 50) return "text-amber-500"
    return "text-red-500"
  }

const getScoreLabel = (score: number) => {
    if (score >= 80) return "Excellent"
    if (score >= 50) return "Good"
    return "Needs Improvement"
  }

const formatDate = (dateStr: string) => {
    return new Date(dateStr).toLocaleString()
  }

const getRiskBadge = (level: string) => {
    const colors = {
      low: "bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200",
      medium: "bg-amber-100 text-amber-800 dark:bg-amber-900 dark:text-amber-200",
      high: "bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200",
    }
    return colors[level as keyof typeof colors] || colors.low
  }

return (
    <div className="min-h-screen bg-black p-4">
      <div className="max-w-4xl mx-auto space-y-6">
        <div className="flex items-center gap-4 mb-6">
          <Link href="/">
            <Button variant="outline" size="sm">
              ← Back to Wallet
            </Button>
          </Link>
          <div>
            <h1 className="text-3xl font-bold text-white">Security Center</h1>
            <p className="text-muted-foreground">Professional-grade security for your crypto assets</p>
          </div>
        </div>

{/* Security Score Card */}
        <Card className="bg-gradient-to-r from-primary/10 to-primary/5 border-primary/20">
          <CardContent className="pt-6">
            <div className="flex items-center justify-between">
              <div className="space-y-1">
                <h3 className="text-lg font-semibold text-white">Security Score</h3>
                <p className="text-sm text-muted-foreground">Based on your current security configuration</p>
              </div>
              <div className="text-center">
                <div className={`text-4xl font-bold ${getScoreColor(securityScore)}`}>
                  {securityScore}%
                </div>
                <Badge variant="secondary" className="mt-1">{getScoreLabel(securityScore)}</Badge>
              </div>
            </div>
            <div className="mt-4 h-2 bg-muted rounded-full overflow-hidden">
              <div 
                className={`h-full transition-all duration-500 ${
                  securityScore >= 80 ? "bg-green-500" : securityScore >= 50 ? "bg-amber-500" : "bg-red-500"
                }`}
                style={{ width: `${securityScore}%` }}
              />
            </div>
          </CardContent>
        </Card>

{/* Tabs Navigation */}
        <Tabs value={activeTab} onValueChange={setActiveTab} className="space-y-4">
          <TabsList className="grid grid-cols-5 w-full">
            <TabsTrigger value="overview">Overview</TabsTrigger>
            <TabsTrigger value="authentication">Auth</TabsTrigger>
            <TabsTrigger value="devices">Devices</TabsTrigger>
            <TabsTrigger value="activity">Activity</TabsTrigger>
            <TabsTrigger value="advanced">Advanced</TabsTrigger>
          </TabsList>

{/* Overview Tab */}
          <TabsContent value="overview" className="space-y-4">
            <div className="grid gap-4 md:grid-cols-2">
              {/* Quick Security Actions */}
              <Card>
                <CardHeader>
                  <CardTitle className="text-lg flex items-center gap-2">
                    <ShieldCheck className="h-5 w-5 text-primary" />
                    Quick Actions
                  </CardTitle>
                </CardHeader>
                <CardContent className="space-y-3">
                  <div className="flex items-center justify-between p-3 bg-muted rounded-lg">
                    <div className="flex items-center gap-3">
                      <Key className="h-4 w-4 text-muted-foreground" />
                      <span className="text-sm">Two-Factor Auth</span>
                    </div>
                    {mfaEnabled ? (
                      <Badge className="bg-green-600">Enabled</Badge>
                    ) : (
                      <Button size="sm" variant="outline" onClick={() => setShowMFASetup(true)}>Enable</Button>
                    )}
                  </div>
                  <div className="flex items-center justify-between p-3 bg-muted rounded-lg">
                    <div className="flex items-center gap-3">
                      <Lock className="h-4 w-4 text-muted-foreground" />
                      <span className="text-sm">Transaction Signing</span>
                    </div>
                    <Switch 
                      checked={securitySettings.transaction_signing}
                      onCheckedChange={(v) => updateSecuritySetting("transaction_signing", v)}
                    />
                  </div>
                  <div className="flex items-center justify-between p-3 bg-muted rounded-lg">
                    <div className="flex items-center gap-3">
                      <Clock className="h-4 w-4 text-muted-foreground" />
                      <span className="text-sm">Auto-Lock ({securitySettings.auto_lock_timeout}min)</span>
                    </div>
                    <Switch 
                      checked={securitySettings.auto_lock_timeout > 0}
                      onCheckedChange={(v) => updateSecuritySetting("auto_lock_timeout", v ? 5 : 0)}
                    />
                  </div>
                  <div className="flex items-center justify-between p-3 bg-muted rounded-lg">
                    <div className="flex items-center gap-3">
                      <Bell className="h-4 w-4 text-muted-foreground" />
                      <span className="text-sm">Security Alerts</span>
                    </div>
                    <Switch 
                      checked={securitySettings.security_alerts}
                      onCheckedChange={(v) => updateSecuritySetting("security_alerts", v)}
                    />
                  </div>
                </CardContent>
              </Card>

{/* Recent Activity */}
              <Card>
                <CardHeader>
                  <CardTitle className="text-lg flex items-center gap-2">
                    <History className="h-5 w-5 text-primary" />
                    Recent Activity
                  </CardTitle>
                </CardHeader>
                <CardContent>
                  {securityEvents.length === 0 ? (
                    <p className="text-sm text-muted-foreground text-center py-4">No recent activity</p>
                  ) : (
                    <div className="space-y-2">
                      {securityEvents.slice(0, 5).map((event) => (
                        <div key={event.id} className="flex items-center justify-between py-2 border-b border-border last:border-0">
                          <div className="space-y-0.5">
                            <p className="text-sm font-medium">{event.description}</p>
                            <p className="text-xs text-muted-foreground">{formatDate(event.created_at)}</p>
                          </div>
                          <Badge className={getRiskBadge(event.risk_level)}>{event.risk_level}</Badge>
                        </div>
                      ))}
                    </div>
                  )}
                  <Button variant="ghost" className="w-full mt-2" onClick={() => setActiveTab("activity")}>
                    View All Activity <ChevronRight className="h-4 w-4 ml-1" />
                  </Button>
                </CardContent>
              </Card>
            </div>

{/* Active Sessions Summary */}
            <Card>
              <CardHeader>
                <CardTitle className="text-lg flex items-center gap-2">
                  <Monitor className="h-5 w-5 text-primary" />
                  Active Sessions
                </CardTitle>
                <CardDescription>
                  {activeSessions.length} active session(s) on your account
                </CardDescription>
              </CardHeader>
              <CardContent>
                {activeSessions.length > 1 && (
                  <Button variant="destructive" size="sm" onClick={terminateAllSessions}>
                    <LogOut className="h-4 w-4 mr-2" />
                    Sign Out All Other Devices
                  </Button>
                )}
              </CardContent>
            </Card>
          </TabsContent>

{/* Authentication Tab */}
          <TabsContent value="authentication" className="space-y-4">
            {/* MFA Section */}
            <Card>
          <CardHeader>
            <CardTitle className="flex items-center gap-2">
              <Shield className="w-5 h-5 text-primary" />
              Two-Factor Authentication (2FA)
            </CardTitle>
            <CardDescription>
              Add an extra layer of security to your crypto wallet with authenticator app
            </CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="flex items-center justify-between p-4 border rounded-lg">
              <div className="space-y-1">
                <div className="font-medium flex items-center gap-2">
                  Status:{" "}
                  {mfaEnabled ? (
                    <span className="text-green-600 dark:text-green-400 flex items-center gap-1">
                      <Check className="w-4 h-4" /> Enabled
                    </span>
                  ) : (
                    <span className="text-orange-600 dark:text-orange-400 flex items-center gap-1">
                      <X className="w-4 h-4" /> Disabled
                    </span>
                  )}
                </div>
                {mfaEnabled && (
                  <p className="text-sm text-muted-foreground">Backup codes remaining: {backupCodesCount}</p>
                )}
              </div>
              {mfaEnabled ? (
                <Button variant="destructive" onClick={handleDisableMFA} disabled={loading}>
                  Disable 2FA
                </Button>
              ) : (
                <Button onClick={() => setShowMFASetup(true)} disabled={loading}>
                  Enable 2FA
                </Button>
              )}
            </div>

{!mfaEnabled && (
              <div className="p-4 bg-orange-50 dark:bg-orange-950 border border-orange-200 dark:border-orange-800 rounded-lg">
                <div className="flex gap-3">
                  <AlertTriangle className="w-5 h-5 text-orange-600 dark:text-orange-400 flex-shrink-0 mt-0.5" />
                  <div>
                    <p className="font-medium text-orange-900 dark:text-orange-100">
                      Two-factor authentication is disabled
                    </p>
                    <p className="text-sm text-orange-700 dark:text-orange-300 mt-1">
                      Enable 2FA to protect your crypto wallet from unauthorized access. This adds a code from your
                      phone that's required along with your password.
                    </p>
                  </div>
                </div>
              </div>
            )}
          </CardContent>
        </Card>

{/* Password Section */}
        <Card>
          <CardHeader>
            <CardTitle>Password</CardTitle>
            <CardDescription>Change your password regularly to keep your account secure</CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            {!showPasswordChange ? (
              <Button onClick={() => setShowPasswordChange(true)} variant="outline">
                Change Password
              </Button>
            ) : (
              <div className="space-y-4">
                <div className="space-y-2">
                  <Label htmlFor="current-password">Current Password</Label>
                  <div className="relative">
                    <Input
                      id="current-password"
                      type={showCurrentPassword ? "text" : "password"}
                      value={currentPassword}
                      onChange={(e) => setCurrentPassword(e.target.value)}
                      placeholder="Enter your current password"
                    />
                    <button
                      type="button"
                      onClick={() => setShowCurrentPassword(!showCurrentPassword)}
                      className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                    >
                      {showCurrentPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                    </button>
                  </div>
                </div>

<div className="space-y-2">
                  <Label htmlFor="new-password">New Password</Label>
                  <div className="relative">
                    <Input
                      id="new-password"
                      type={showNewPassword ? "text" : "password"}
                      value={newPassword}
                      onChange={(e) => setNewPassword(e.target.value)}
                      placeholder="Enter your new password"
                    />
                    <button
                      type="button"
                      onClick={() => setShowNewPassword(!showNewPassword)}
                      className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                    >
                      {showNewPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                    </button>
                  </div>
                  {newPassword && (
                    <div className="space-y-2">
                      <div className="flex items-center gap-2">
                        <div className="flex-1 h-2 bg-muted rounded-full overflow-hidden">
                          <div
                            className={`h-full transition-all ${
                              passwordStrength.score <= 2
                                ? "bg-red-500"
                                : passwordStrength.score <= 4
                                  ? "bg-orange-500"
                                  : passwordStrength.score <= 6
                                    ? "bg-yellow-500"
                                    : "bg-green-500"
                            }`}
                            style={{ width: `${(passwordStrength.score / 8) * 100}%` }}
                          />
                        </div>
                        <span className={`text-xs font-medium ${passwordStrength.color}`}>
                          {passwordStrength.label}
                        </span>
                      </div>
                      {passwordStrength.feedback.length > 0 && (
                        <ul className="text-xs text-muted-foreground space-y-1">
                          {passwordStrength.feedback.map((fb, i) => (
                            <li key={i}>• {fb}</li>
                          ))}
                        </ul>
                      )}
                    </div>
                  )}
                </div>

<div className="space-y-2">
                  <Label htmlFor="confirm-password">Confirm New Password</Label>
                  <Input
                    id="confirm-password"
                    type="password"
                    value={confirmPassword}
                    onChange={(e) => setConfirmPassword(e.target.value)}
                    placeholder="Confirm your new password"
                  />
                </div>

<div className="flex gap-2">
                  <Button
                    onClick={handlePasswordChange}
                    disabled={
                      loading || !currentPassword || !newPassword || !confirmPassword || !passwordStrength.isSecure
                    }
                  >
                    {loading ? "Updating..." : "Update Password"}
                  </Button>
                  <Button
                    variant="outline"
                    onClick={() => {
                      setShowPasswordChange(false)
                      setCurrentPassword("")
                      setNewPassword("")
                      setConfirmPassword("")
                      setError("")
                    }}
                  >
                    Cancel
                  </Button>
                </div>
              </div>
            )}
          </CardContent>
        </Card>

{/* Wallet Export Section */}
        <Card>
          <CardHeader>
            <CardTitle className="flex items-center gap-2">
              <Shield className="w-5 h-5 text-primary" />
              Export Wallet Private Key
            </CardTitle>
            <CardDescription>
              Export your wallet's private key to import it into MetaMask or other wallets
            </CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            {!showWalletExport ? (
              <div className="space-y-4">
                <div className="p-4 bg-orange-50 dark:bg-orange-950 border border-orange-200 dark:border-orange-800 rounded-lg">
                  <div className="flex gap-3">
                    <AlertTriangle className="w-5 h-5 text-orange-600 dark:text-orange-400 flex-shrink-0 mt-0.5" />
                    <div>
                      <p className="font-medium text-orange-900 dark:text-orange-100">Warning</p>
                      <p className="text-sm text-orange-700 dark:text-orange-300 mt-1">
                        Never share your private key with anyone. Anyone with your private key has full access to your
                        wallet and funds.
                      </p>
                    </div>
                  </div>
                </div>
                <Button onClick={() => setShowWalletExport(true)} variant="outline">
                  Export Private Key
                </Button>
              </div>
            ) : (
              <div className="space-y-4">
                {!exportedPrivateKey ? (
                  <>
                    <div className="p-4 bg-red-50 dark:bg-red-950 border border-red-200 dark:border-red-800 rounded-lg">
                      <div className="flex gap-3">
                        <AlertTriangle className="w-5 h-5 text-red-600 dark:text-red-400 flex-shrink-0 mt-0.5" />
                        <div>
                          <p className="font-medium text-red-900 dark:text-red-100">Security Warning</p>
                          <ul className="text-sm text-red-700 dark:text-red-300 mt-1 space-y-1">
                            <li>• Never share your private key with anyone</li>
                            <li>• Store it in a secure, offline location</li>
                            <li>• Anyone with access to this key can control your funds</li>
                          </ul>
                        </div>
                      </div>
                    </div>

<div className="space-y-2">
                      <Label htmlFor="export-password">Account Password</Label>
                      <div className="relative">
                        <Input
                          id="export-password"
                          type={showExportPassword ? "text" : "password"}
                          value={exportPassword}
                          onChange={(e) => setExportPassword(e.target.value)}
                          placeholder="Enter your account password"
                          onKeyDown={(e) => e.key === "Enter" && handleExportWallet()}
                        />
                        <button
                          type="button"
                          onClick={() => setShowExportPassword(!showExportPassword)}
                          className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                        >
                          {showExportPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                        </button>
                      </div>
                      <p className="text-xs text-muted-foreground">
                        This is the password you use to log into your account
                      </p>
                    </div>

{exportError && (
                      <div className="p-3 bg-red-50 dark:bg-red-950 border border-red-200 dark:border-red-800 rounded text-red-900 dark:text-red-100 text-sm">
                        {exportError}
                      </div>
                    )}

<div className="flex gap-2">
                      <Button onClick={handleExportWallet} disabled={exportLoading || !exportPassword}>
                        {exportLoading ? "Decrypting..." : "Decrypt & Export"}
                      </Button>
                      <Button variant="outline" onClick={resetExportForm}>
                        Cancel
                      </Button>
                    </div>
                  </>
                ) : (
                  <>
                    <div className="space-y-3">
                      <div className="space-y-2">
                        <Label>Wallet Address</Label>
                        <div className="flex gap-2">
                          <Input value={walletAddress} readOnly className="font-mono text-sm" />
                          <Button
                            variant="outline"
                            size="sm"
                            onClick={() => copyToClipboard(walletAddress)}
                            className="shrink-0"
                          >
                            Copy
                          </Button>
                        </div>
                      </div>

<div className="space-y-2">
                        <Label>Private Key</Label>
                        <div className="flex gap-2">
                          <Input value={exportedPrivateKey} readOnly type="password" className="font-mono text-sm" />
                          <Button
                            variant="outline"
                            size="sm"
                            onClick={() => copyToClipboard(exportedPrivateKey)}
                            className="shrink-0"
                          >
                            Copy
                          </Button>
                        </div>
                        <p className="text-xs text-muted-foreground">
                          Click "Copy" to copy your private key. Store it securely offline.
                        </p>
                      </div>
                    </div>

<div className="p-4 bg-blue-50 dark:bg-blue-950 border border-blue-200 dark:border-blue-800 rounded-lg">
                      <p className="font-medium text-blue-900 dark:text-blue-100 mb-2">Import to MetaMask:</p>
                      <ol className="text-sm text-blue-700 dark:text-blue-300 space-y-1">
                        <li>1. Open MetaMask and click your account icon</li>
                        <li>2. Select "Import Account"</li>
                        <li>3. Paste your private key</li>
                        <li>4. Click "Import"</li>
                      </ol>
                    </div>

{/* Security Tips */}
            <Card>
              <CardHeader>
                <CardTitle>Security Best Practices</CardTitle>
              </CardHeader>
              <CardContent>
                <ul className="space-y-3 text-sm">
                  <li className="flex items-start gap-2">
                    <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
                    <span>Use a strong, unique password for your LinkFiCrypto account</span>
                  </li>
                  <li className="flex items-start gap-2">
                    <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
                    <span>Enable two-factor authentication for maximum security</span>
                  </li>
                  <li className="flex items-start gap-2">
                    <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
                    <span>Never share your password, recovery phrase, or backup codes</span>
                  </li>
                  <li className="flex items-start gap-2">
                    <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
                    <span>Regularly review your account activity and connected devices</span>
                  </li>
                  <li className="flex items-start gap-2">
                    <Check className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
                    <span>Store your backup codes in a secure location offline</span>
                  </li>
                </ul>
              </CardContent>
            </Card>
          </TabsContent>

{/* Devices Tab */}
          <TabsContent value="devices" className="space-y-4">
            <Card>
              <CardHeader>
                <CardTitle className="flex items-center gap-2">
                  <Smartphone className="h-5 w-5 text-primary" />
                  Trusted Devices
                </CardTitle>
                <CardDescription>
                  Devices you've authorized to access your account
                </CardDescription>
              </CardHeader>
              <CardContent>
                {trustedDevices.length === 0 ? (
                  <div className="text-center py-8 text-muted-foreground">
                    <Smartphone className="h-12 w-12 mx-auto mb-3 opacity-50" />
                    <p>No trusted devices</p>
                    <p className="text-sm">Devices will appear here when you trust them during login</p>
                  </div>
                ) : (
                  <div className="space-y-3">
                    {trustedDevices.map((device) => (
                      <div
                        key={device.id}
                        className="flex items-center justify-between p-4 border rounded-lg"
                      >
                        <div className="flex items-center gap-3">
                          {device.device_type === "mobile" ? (
                            <Smartphone className="h-5 w-5 text-muted-foreground" />
                          ) : (
                            <Monitor className="h-5 w-5 text-muted-foreground" />
                          )}
                          <div>
                            <p className="font-medium">{device.device_name}</p>
                            <p className="text-sm text-muted-foreground">
                              {device.browser} on {device.os}
                            </p>
                            <p className="text-xs text-muted-foreground">
                              Last used: {formatDate(device.last_used)}
                            </p>
                          </div>
                        </div>
                        <Button
                          variant="ghost"
                          size="sm"
                          onClick={() => revokeDevice(device.id)}
                          className="text-destructive hover:text-destructive"
                        >
                          <Trash2 className="h-4 w-4" />
                        </Button>
                      </div>
                    ))}
                  </div>
                )}
              </CardContent>
            </Card>

{/* Active Sessions */}
            <Card>
              <CardHeader>
                <div className="flex items-center justify-between">
                  <div>
                    <CardTitle className="flex items-center gap-2">
                      <Globe className="h-5 w-5 text-primary" />
                      Active Sessions
                    </CardTitle>
                    <CardDescription>
                      Sessions currently signed into your account
                    </CardDescription>
                  </div>
                  {activeSessions.length > 1 && (
                    <Button variant="destructive" size="sm" onClick={terminateAllSessions}>
                      <LogOut className="h-4 w-4 mr-2" />
                      End All Others
                    </Button>
                  )}
                </div>
              </CardHeader>
              <CardContent>
                {activeSessions.length === 0 ? (
                  <div className="text-center py-8 text-muted-foreground">
                    <Globe className="h-12 w-12 mx-auto mb-3 opacity-50" />
                    <p>No active sessions found</p>
                  </div>
                ) : (
                  <div className="space-y-3">
                    {activeSessions.map((session) => (
                      <div
                        key={session.id}
                        className={`flex items-center justify-between p-4 border rounded-lg ${
                          session.is_current ? "border-primary bg-primary/5" : ""
                        }`}
                      >
                        <div className="flex items-center gap-3">
                          <Globe className="h-5 w-5 text-muted-foreground" />
                          <div>
                            <p className="font-medium flex items-center gap-2">
                              {session.ip_address}
                              {session.is_current && (
                                <Badge variant="secondary" className="text-xs">Current</Badge>
                              )}
                            </p>
                            <p className="text-sm text-muted-foreground">
                              {session.location || "Unknown location"}
                            </p>
                            <p className="text-xs text-muted-foreground">
                              Last activity: {formatDate(session.last_activity)}
                            </p>
                          </div>
                        </div>
                        {!session.is_current && (
                          <Button
                            variant="ghost"
                            size="sm"
                            onClick={() => terminateSession(session.id)}
                            className="text-destructive hover:text-destructive"
                          >
                            <LogOut className="h-4 w-4" />
                          </Button>
                        )}
                      </div>
                    ))}
                  </div>
                )}
              </CardContent>
            </Card>
          </TabsContent>

{/* Activity Tab */}
          <TabsContent value="activity" className="space-y-4">
            <Card>
              <CardHeader>
                <div className="flex items-center justify-between">
                  <div>
                    <CardTitle className="flex items-center gap-2">
                      <History className="h-5 w-5 text-primary" />
                      Security Activity Log
                    </CardTitle>
                    <CardDescription>
                      Recent security-related events on your account
                    </CardDescription>
                  </div>
                  <Button variant="outline" size="sm" onClick={() => user && fetchSecurityData(user.id)}>
                    <RefreshCw className="h-4 w-4 mr-2" />
                    Refresh
                  </Button>
                </div>
              </CardHeader>
              <CardContent>
                {securityEvents.length === 0 ? (
                  <div className="text-center py-8 text-muted-foreground">
                    <History className="h-12 w-12 mx-auto mb-3 opacity-50" />
                    <p>No security events recorded</p>
                  </div>
                ) : (
                  <div className="space-y-2">
                    {securityEvents.map((event) => (
                      <div
                        key={event.id}
                        className="flex items-start justify-between p-3 border rounded-lg hover:bg-muted/50 transition-colors"
                      >
                        <div className="flex items-start gap-3">
                          <div className={`p-2 rounded-full ${
                            event.risk_level === "high" ? "bg-red-100 dark:bg-red-900" :
                            event.risk_level === "medium" ? "bg-amber-100 dark:bg-amber-900" :
                            "bg-green-100 dark:bg-green-900"
                          }`}>
                            {event.risk_level === "high" ? (
                              <ShieldAlert className="h-4 w-4 text-red-600 dark:text-red-400" />
                            ) : event.risk_level === "medium" ? (
                              <AlertTriangle className="h-4 w-4 text-amber-600 dark:text-amber-400" />
                            ) : (
                              <ShieldCheck className="h-4 w-4 text-green-600 dark:text-green-400" />
                            )}
                          </div>
                          <div>
                            <p className="font-medium text-sm">{event.description}</p>
                            <div className="flex items-center gap-2 text-xs text-muted-foreground mt-1">
                              <span>{formatDate(event.created_at)}</span>
                              <span>•</span>
                              <span>{event.ip_address}</span>
                              {event.location && (
                                <>
                                  <span>•</span>
                                  <span>{event.location}</span>
                                </>
                              )}
                            </div>
                          </div>
                        </div>
                        <Badge className={getRiskBadge(event.risk_level)}>
                          {event.risk_level}
                        </Badge>
                      </div>
                    ))}
                  </div>
                )}
              </CardContent>
            </Card>
          </TabsContent>

{/* Advanced Tab */}
          <TabsContent value="advanced" className="space-y-4">
            {/* Notification Settings */}
            <Card>
              <CardHeader>
                <CardTitle className="flex items-center gap-2">
                  <Bell className="h-5 w-5 text-primary" />
                  Security Notifications
                </CardTitle>
                <CardDescription>
                  Configure how you receive security alerts
                </CardDescription>
              </CardHeader>
              <CardContent className="space-y-4">
                <div className="flex items-center justify-between p-3 border rounded-lg">
                  <div>
                    <p className="font-medium">Login Notifications</p>
                    <p className="text-sm text-muted-foreground">Get notified of new sign-ins</p>
                  </div>
                  <Switch
                    checked={securitySettings.login_notifications}
                    onCheckedChange={(v) => updateSecuritySetting("login_notifications", v)}
                  />
                </div>
                <div className="flex items-center justify-between p-3 border rounded-lg">
                  <div>
                    <p className="font-medium">Transaction Notifications</p>
                    <p className="text-sm text-muted-foreground">Get notified of all transactions</p>
                  </div>
                  <Switch
                    checked={securitySettings.transaction_notifications}
                    onCheckedChange={(v) => updateSecuritySetting("transaction_notifications", v)}
                  />
                </div>
                <div className="flex items-center justify-between p-3 border rounded-lg">
                  <div>
                    <p className="font-medium">Security Alerts</p>
                    <p className="text-sm text-muted-foreground">Get notified of suspicious activity</p>
                  </div>
                  <Switch
                    checked={securitySettings.security_alerts}
                    onCheckedChange={(v) => updateSecuritySetting("security_alerts", v)}
                  />
                </div>
              </CardContent>
            </Card>

{/* Advanced Security */}
            <Card>
              <CardHeader>
                <CardTitle className="flex items-center gap-2">
                  <ShieldCheck className="h-5 w-5 text-primary" />
                  Advanced Security
                </CardTitle>
              </CardHeader>
              <CardContent className="space-y-4">
                <div className="flex items-center justify-between p-3 border rounded-lg">
                  <div>
                    <p className="font-medium">Withdrawal Whitelist Only</p>
                    <p className="text-sm text-muted-foreground">Only allow withdrawals to whitelisted addresses</p>
                  </div>
                  <Switch
                    checked={securitySettings.withdrawal_whitelist_only}
                    onCheckedChange={(v) => updateSecuritySetting("withdrawal_whitelist_only", v)}
                  />
                </div>
                <div className="flex items-center justify-between p-3 border rounded-lg">
                  <div>
                    <p className="font-medium">Auto-Lock Wallet</p>
                    <p className="text-sm text-muted-foreground">
                      Lock wallet after {securitySettings.auto_lock_timeout} minutes of inactivity
                    </p>
                  </div>
                  <div className="flex items-center gap-2">
                    <select
                      value={securitySettings.auto_lock_timeout}
                      onChange={(e) => updateSecuritySetting("auto_lock_timeout", parseInt(e.target.value))}
                      className="border rounded-md px-2 py-1 text-sm bg-background"
                    >
                      <option value={0}>Disabled</option>
                      <option value={1}>1 minute</option>
                      <option value={5}>5 minutes</option>
                      <option value={15}>15 minutes</option>
                      <option value={30}>30 minutes</option>
                      <option value={60}>1 hour</option>
                    </select>
                  </div>
                </div>
              </CardContent>
            </Card>
          </TabsContent>
        </Tabs>

{error && (
          <div className="p-4 bg-red-50 dark:bg-red-950 border border-red-200 dark:border-red-800 rounded-lg text-red-900 dark:text-red-100">
            {error}
          </div>
        )}

{success && (
          <div className="p-4 bg-green-50 dark:bg-green-950 border border-green-200 dark:border-green-800 rounded-lg text-green-900 dark:text-green-100">
            {success}
          </div>
        )}
      </div>

{user && (
        <MFASetup
          open={showMFASetup}
          onClose={() => setShowMFASetup(false)}
          userId={user.id}
          userEmail={user.email}
          onComplete={() => {
            setMfaEnabled(true)
            checkAuth()
          }}
        />
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/layout.tsx" isMerged="true"
import type React from "react"
import type { Metadata } from "next"
import { Geist, Geist_Mono } from "next/font/google"
import { Analytics } from "@vercel/analytics/next"
import Script from "next/script"
import "./globals.css"
import { Footer } from "@/components/footer"
import { SiteVerificationBanner } from "@/components/phishing-protection"

const _geist = Geist({ subsets: ["latin"] })
const _geistMono = Geist_Mono({ subsets: ["latin"] })

// JSON-LD structured data
const jsonLd = {
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      name: "LinkFiCrypto",
      alternateName: ["LinkFi Crypto", "linkficrypto"],
      url: "https://linkficrypto.com",
      logo: "https://linkficrypto.com/favicon.ico",
      description: "Non-custodial cryptocurrency wallet platform for secure DeFi access",
      sameAs: ["https://twitter.com/linkficrypto"],
      brand: {
        "@type": "Brand",
        name: "LinkFiCrypto",
      },
    },
    {
      "@type": "WebApplication",
      name: "LinkFiCrypto",
      alternateName: "linkficrypto",
      url: "https://linkficrypto.com",
      description:
        "Non-custodial cryptocurrency wallet for secure DeFi access. Connect MetaMask, Base, or Trust Wallet to send, receive, and swap tokens.",
      applicationCategory: "FinanceApplication",
      operatingSystem: "Web Browser",
      browserRequirements: "Requires JavaScript. Requires HTML5.",
      offers: {
        "@type": "Offer",
        price: "0",
        priceCurrency: "USD",
      },
      featureList: [
        "Connect multiple wallets (MetaMask, Base, Trust Wallet)",
        "Send cryptocurrency",
        "Receive cryptocurrency",
        "Swap tokens with best rates",
        "Non-custodial security - you control your keys",
        "Built-in wallet creation",
        "Transaction history tracking",
        "Portfolio analytics",
      ],
    },
    {
      "@type": "WebSite",
      name: "LinkFiCrypto",
      url: "https://linkficrypto.com",
      potentialAction: {
        "@type": "SearchAction",
        target: {
          "@type": "EntryPoint",
          urlTemplate: "https://linkficrypto.com/?search={search_term_string}",
        },
        "query-input": "required name=search_term_string",
      },
    },
  ],
}

export const metadata: Metadata = {
  metadataBase: new URL("https://linkficrypto.com"),
  title: {
    default: "LinkFiCrypto - Non-Custodial Crypto Wallet | Secure DeFi Platform",
    template: "%s | LinkFiCrypto",
  },
  description:
    "LinkFiCrypto is a secure non-custodial cryptocurrency wallet platform. Connect any Web3 wallet (MetaMask, Base, Trust Wallet), send, receive, and swap tokens with the best DeFi rates. Your keys, your crypto.",
  keywords: [
    "LinkFiCrypto",
    "linkficrypto",
    "linkfi crypto",
    "crypto wallet",
    "non-custodial wallet",
    "DeFi platform",
    "cryptocurrency wallet",
    "Web3 wallet",
    "token swap",
    "MetaMask alternative",
    "Base",
    "Base Wallet",
    "Trust Wallet",
    "blockchain wallet",
    "decentralized finance",
    "crypto exchange",
    "send crypto",
    "receive crypto",
    "swap tokens",
    "secure crypto wallet",
    "non custodial crypto",
  ],
  authors: [{ name: "LinkFiCrypto Team" }],
  creator: "LinkFiCrypto",
  publisher: "LinkFiCrypto",
  formatDetection: {
    email: false,
    address: false,
    telephone: false,
  },
  openGraph: {
    type: "website",
    locale: "en_US",
    url: "https://linkficrypto.com",
    siteName: "LinkFiCrypto",
    title: "LinkFiCrypto - Non-Custodial Crypto Wallet | Secure DeFi Platform",
    description:
      "LinkFiCrypto: Connect your wallet and swap tokens with the best rates. Non-custodial, secure, and easy to use. Join thousands managing their crypto safely with LinkFiCrypto.",
    images: [
      {
        url: "/og-image.jpg",
        width: 1200,
        height: 630,
        alt: "LinkFiCrypto - Secure Non-Custodial Crypto Wallet Platform",
        type: "image/jpeg",
      },
    ],
  },
  twitter: {
    card: "summary_large_image",
    title: "LinkFiCrypto - Non-Custodial Crypto Wallet",
    description:
      "LinkFiCrypto: Connect your wallet and swap tokens with the best rates. Non-custodial, secure, and easy to use.",
    images: ["/og-image.jpg"],
    creator: "@linkficrypto",
    site: "@linkficrypto",
  },
  robots: {
    index: true,
    follow: true,
    googleBot: {
      index: true,
      follow: true,
      "max-video-preview": -1,
      "max-image-preview": "large",
      "max-snippet": -1,
    },
  },
  verification: {
    google: "google-site-verification-code",
  },
  alternates: {
    canonical: "https://linkficrypto.com",
  },
  generator: "v0.app",
  icons: {
    icon: [
      { url: "/favicon.ico", sizes: "any" },
      { url: "/favicon.ico", sizes: "16x16", type: "image/x-icon" },
      { url: "/favicon.ico", sizes: "32x32", type: "image/x-icon" },
      { url: "/favicon.ico", sizes: "48x48", type: "image/x-icon" },
    ],
    apple: [
      { url: "/favicon.ico", sizes: "180x180", type: "image/x-icon" },
      { url: "/favicon.ico", sizes: "167x167", type: "image/x-icon" },
      { url: "/favicon.ico", sizes: "152x152", type: "image/x-icon" },
      { url: "/favicon.ico", sizes: "120x120", type: "image/x-icon" },
    ],
    shortcut: ["/favicon.ico"],
    other: [
      { rel: "icon", url: "/favicon.ico", sizes: "any" },
      { rel: "apple-touch-icon", url: "/favicon.ico" },
    ],
  },
}

export default function RootLayout({
  children,
}: Readonly<{
  children: React.ReactNode
}>) {
  return (
    <html lang="en">
      <head>
        <link rel="icon" type="image/x-icon" href="/favicon.ico" />
        <link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" />
        <link rel="apple-touch-icon" href="/favicon.ico" />
        <link rel="apple-touch-icon" sizes="180x180" href="/favicon.ico" />
        <link rel="apple-touch-icon" sizes="167x167" href="/favicon.ico" />
        <link rel="apple-touch-icon" sizes="152x152" href="/favicon.ico" />
        <link rel="apple-touch-icon" sizes="120x120" href="/favicon.ico" />
        <link rel="apple-touch-icon-precomposed" href="/favicon.ico" />
        <meta name="theme-color" content="#000000" />
        <meta name="apple-mobile-web-app-capable" content="yes" />
        <meta name="apple-mobile-web-app-status-bar-style" content="black" />
        <meta name="apple-mobile-web-app-title" content="LinkFiCrypto" />
        <meta property="og:site_name" content="LinkFiCrypto" />
        <meta name="application-name" content="LinkFiCrypto" />
        <meta name="msapplication-TileColor" content="#000000" />
        <meta name="msapplication-TileImage" content="/favicon.ico" />
        <meta name="msapplication-config" content="/browserconfig.xml" />
      </head>
      <body className={`font-sans antialiased flex flex-col min-h-screen`}>
        <Script
          id="json-ld"
          type="application/ld+json"
          strategy="afterInteractive"
          dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
        />
        <main className="flex-1">{children}</main>
        <Footer />
        <SiteVerificationBanner />
        <Analytics />
        <Script src="https://cdn.jsdelivr.net/npm/jsqr@1.4.0/dist/jsQR.min.js" strategy="afterInteractive" />
        <Script src="https://www.googletagmanager.com/gtag/js?id=G-8HYHLLG3ZV" strategy="afterInteractive" />
        <Script id="google-analytics" strategy="afterInteractive">
          {`
            window.dataLayer = window.dataLayer || [];
            function gtag(){dataLayer.push(arguments);}
            gtag('js', new Date());
            gtag('config', 'G-8HYHLLG3ZV');
          `}
        </Script>
      </body>
    </html>
  )
}
[V0_FILE]typescript:file="hooks/use-security.ts" isMerged="true"
"use client"

import { useState, useEffect, useCallback } from "react"

interface DeviceInfo {
  fingerprint: string
  deviceName: string
  deviceType: "desktop" | "mobile" | "tablet"
  browser: string
  os: string
}

// Generate a device fingerprint
export function generateDeviceFingerprint(): string {
  if (typeof window === "undefined") return ""
  
  const canvas = document.createElement("canvas")
  const ctx = canvas.getContext("2d")
  if (ctx) {
    ctx.textBaseline = "top"
    ctx.font = "14px Arial"
    ctx.fillText("fingerprint", 2, 2)
  }
  
  const components = [
    navigator.userAgent,
    navigator.language,
    new Date().getTimezoneOffset().toString(),
    screen.colorDepth.toString(),
    `${screen.width}x${screen.height}`,
    navigator.hardwareConcurrency?.toString() || "",
    canvas.toDataURL(),
  ]
  
  // Simple hash function
  const str = components.join("|")
  let hash = 0
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i)
    hash = ((hash << 5) - hash) + char
    hash = hash & hash
  }
  return Math.abs(hash).toString(36)
}

// Get device info
export function getDeviceInfo(): DeviceInfo {
  if (typeof window === "undefined") {
    return {
      fingerprint: "",
      deviceName: "Unknown Device",
      deviceType: "desktop",
      browser: "Unknown",
      os: "Unknown",
    }
  }

const ua = navigator.userAgent
  
  // Detect device type
  let deviceType: "desktop" | "mobile" | "tablet" = "desktop"
  if (/Mobi|Android/i.test(ua)) {
    deviceType = "mobile"
  } else if (/Tablet|iPad/i.test(ua)) {
    deviceType = "tablet"
  }
  
  // Detect browser
  let browser = "Unknown"
  if (ua.includes("Chrome")) browser = "Chrome"
  else if (ua.includes("Firefox")) browser = "Firefox"
  else if (ua.includes("Safari")) browser = "Safari"
  else if (ua.includes("Edge")) browser = "Edge"
  
  // Detect OS
  let os = "Unknown"
  if (ua.includes("Windows")) os = "Windows"
  else if (ua.includes("Mac")) os = "macOS"
  else if (ua.includes("Linux")) os = "Linux"
  else if (ua.includes("Android")) os = "Android"
  else if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) os = "iOS"
  
  // Generate device name
  const deviceName = `${browser} on ${os}`
  
  return {
    fingerprint: generateDeviceFingerprint(),
    deviceName,
    deviceType,
    browser,
    os,
  }
}

// Security hook for managing security state
export function useSecurity(userId: string | undefined) {
  const [settings, setSettings] = useState<SecuritySettings>({
    two_factor_enabled: false,
    biometric_enabled: false,
    transaction_signing: true,
    auto_lock_timeout: 5,
    withdrawal_whitelist_only: false,
    login_notifications: true,
    transaction_notifications: true,
    security_alerts: true,
  })
  const [loading, setLoading] = useState(true)
  const [deviceInfo, setDeviceInfo] = useState<DeviceInfo | null>(null)
  const [isTrustedDevice, setIsTrustedDevice] = useState(false)

useEffect(() => {
    const info = getDeviceInfo()
    setDeviceInfo(info)
    
    if (userId) {
      fetchSettings()
      checkDeviceTrust(info.fingerprint)
    }
  }, [userId])

const fetchSettings = async () => {
    if (!userId) return
    
    try {
      const res = await fetch(`/api/security?userId=${userId}&action=settings`)
      if (res.ok) {
        const data = await res.json()
        setSettings(data)
      }
    } catch (err) {
      console.error("Error fetching security settings:", err)
    } finally {
      setLoading(false)
    }
  }

const checkDeviceTrust = async (fingerprint: string) => {
    if (!userId) return
    
    try {
      const res = await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "checkDeviceTrust",
          userId,
          fingerprint,
        }),
      })
      
      if (res.ok) {
        const data = await res.json()
        setIsTrustedDevice(data.isTrusted)
      }
    } catch (err) {
      console.error("Error checking device trust:", err)
    }
  }

const logSecurityEvent = useCallback(async (
    eventType: string,
    description: string,
    riskLevel: "low" | "medium" | "high" = "low",
    metadata?: Record<string, any>
  ) => {
    if (!userId) return
    
    try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "logEvent",
          userId,
          eventType,
          description,
          riskLevel,
          fingerprint: deviceInfo?.fingerprint,
          userAgent: navigator.userAgent,
          metadata,
        }),
      })
    } catch (err) {
      console.error("Error logging security event:", err)
    }
  }, [userId, deviceInfo])

const trustCurrentDevice = useCallback(async () => {
    if (!userId || !deviceInfo) return false
    
    try {
      const res = await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "trustDevice",
          userId,
          fingerprint: deviceInfo.fingerprint,
          deviceName: deviceInfo.deviceName,
          deviceType: deviceInfo.deviceType,
          browser: deviceInfo.browser,
          os: deviceInfo.os,
        }),
      })
      
      if (res.ok) {
        setIsTrustedDevice(true)
        return true
      }
    } catch (err) {
      console.error("Error trusting device:", err)
    }
    return false
  }, [userId, deviceInfo])

const updateSetting = useCallback(async (key: keyof SecuritySettings, value: any) => {
    if (!userId) return
    
    const newSettings = { ...settings, [key]: value }
    setSettings(newSettings)
    
    try {
      await fetch("/api/security", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          action: "updateSettings",
          userId,
          settings: newSettings,
        }),
      })
    } catch (err) {
      console.error("Error updating security setting:", err)
    }
  }, [userId, settings])

return {
    settings,
    loading,
    deviceInfo,
    isTrustedDevice,
    logSecurityEvent,
    trustCurrentDevice,
    updateSetting,
    refreshSettings: fetchSettings,
  }
}

// Hook for transaction confirmation
export function useTransactionConfirmation() {
  const [showConfirmation, setShowConfirmation] = useState(false)
  const [transactionDetails, setTransactionDetails] = useState<any>(null)
  const [onConfirm, setOnConfirm] = useState<(() => void) | null>(null)
  const [onCancel, setOnCancel] = useState<(() => void) | null>(null)

const requestConfirmation = (
    details: any,
    confirmCallback: () => void,
    cancelCallback?: () => void
  ) => {
    setTransactionDetails(details)
    setOnConfirm(() => confirmCallback)
    setOnCancel(() => cancelCallback || (() => setShowConfirmation(false)))
    setShowConfirmation(true)
  }

const handleConfirm = () => {
    onConfirm?.()
    setShowConfirmation(false)
    setTransactionDetails(null)
  }

const handleCancel = () => {
    onCancel?.()
    setShowConfirmation(false)
    setTransactionDetails(null)
  }

return {
    showConfirmation,
    transactionDetails,
    requestConfirmation,
    handleConfirm,
    handleCancel,
  }
}
[V0_FILE]typescriptreact:file="components/phishing-protection.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"
import { AlertTriangle, Shield, ShieldAlert, ShieldCheck, ExternalLink, X, Copy, Check } from "lucide-react"
import { cn } from "@/lib/utils"

// Known malicious patterns and domains
const SUSPICIOUS_PATTERNS = [
  /linkficrypt0/i,
  /l1nkficrypto/i,
  /linkf1crypto/i,
  /linkficrypt\.com/i,
  /linkfi-crypto/i,
  /link-fi-crypto/i,
  /linkficrypto\.(net|org|io|co)/i,
  /metamask.*free/i,
  /coinbase.*giveaway/i,
  /wallet.*connect.*airdrop/i,
  /claim.*token.*free/i,
]

const KNOWN_PHISHING_DOMAINS = [
  "linkficrypt0.com",
  "l1nkficrypto.com",
  "linkf1crypto.com",
  "linkficrypt.com",
  "metamask-wallet.io",
  "coinbase-claim.com",
]

interface PhishingWarningProps {
  url?: string
  address?: string
  onProceed?: () => void
  onCancel?: () => void
}

export function PhishingWarning({ url, address, onProceed, onCancel }: PhishingWarningProps) {
  return (
    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/70 backdrop-blur-sm p-4">
      <Card className="w-full max-w-lg border-2 border-destructive shadow-2xl">
        <CardHeader className="bg-destructive/10">
          <div className="flex items-center gap-3">
            <div className="p-2 bg-destructive rounded-full">
              <ShieldAlert className="h-6 w-6 text-destructive-foreground" />
            </div>
            <div>
              <CardTitle className="text-destructive">Potential Phishing Detected</CardTitle>
              <CardDescription className="text-destructive/80">
                This {url ? "URL" : "address"} may be malicious
              </CardDescription>
            </div>
          </div>
        </CardHeader>
        <CardContent className="pt-6 space-y-4">
          <div className="bg-muted rounded-lg p-4 font-mono text-sm break-all">
            {url || address}
          </div>

<div className="space-y-3">
            <div className="flex items-start gap-3 text-sm">
              <AlertTriangle className="h-5 w-5 text-amber-500 shrink-0 mt-0.5" />
              <p>
                This {url ? "website" : "address"} appears to be impersonating a legitimate service. 
                Interacting with it could result in loss of funds.
              </p>
            </div>
            <div className="flex items-start gap-3 text-sm">
              <Shield className="h-5 w-5 text-blue-500 shrink-0 mt-0.5" />
              <p>
                Always verify you are on the official LinkFiCrypto website (linkficrypto.com) 
                and double-check addresses before sending any funds.
              </p>
            </div>
          </div>

<div className="bg-amber-50 dark:bg-amber-950/30 border border-amber-200 dark:border-amber-800 rounded-lg p-3">
            <p className="text-sm text-amber-800 dark:text-amber-200 font-medium">
              If you did not initiate this action, close this page immediately and do not enter any information.
            </p>
          </div>

<div className="flex gap-3 pt-2">
            <Button variant="outline" onClick={onCancel} className="flex-1">
              Go Back to Safety
            </Button>
            {onProceed && (
              <Button
                variant="destructive"
                onClick={onProceed}
                className="flex-1"
              >
                I Understand the Risk
              </Button>
            )}
          </div>
        </CardContent>
      </Card>
    </div>
  )
}

// Address verification component
interface AddressVerificationProps {
  address: string
  label?: string
  onVerified?: (isVerified: boolean) => void
  showWarnings?: boolean
}

export function AddressVerification({
  address,
  label,
  onVerified,
  showWarnings = true,
}: AddressVerificationProps) {
  const [verificationStatus, setVerificationStatus] = useState<"pending" | "verified" | "warning" | "danger">("pending")
  const [warnings, setWarnings] = useState<string[]>([])
  const [copied, setCopied] = useState(false)

useEffect(() => {
    verifyAddress(address)
  }, [address])

const verifyAddress = async (addr: string) => {
    const newWarnings: string[] = []

// Basic format check
    if (!addr.match(/^0x[a-fA-F0-9]{40}$/)) {
      newWarnings.push("Invalid Ethereum address format")
      setVerificationStatus("danger")
      setWarnings(newWarnings)
      onVerified?.(false)
      return
    }

// Check for known malicious addresses (in production, this would be an API call)
    const knownMalicious = [
      "0x0000000000000000000000000000000000000000",
    ]

if (knownMalicious.includes(addr.toLowerCase())) {
      newWarnings.push("This address has been flagged as potentially malicious")
      setVerificationStatus("danger")
      setWarnings(newWarnings)
      onVerified?.(false)
      return
    }

// Check for contract addresses (simplified check)
    // In production, this would verify on-chain
    
    // Check if address is new (no transactions)
    // In production, this would check on-chain history

// Check for similar addresses (homoglyph attack detection)
    if (newWarnings.length === 0) {
      setVerificationStatus("verified")
      onVerified?.(true)
    } else {
      setVerificationStatus("warning")
      onVerified?.(true)
    }
    
    setWarnings(newWarnings)
  }

const copyAddress = () => {
    navigator.clipboard.writeText(address)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

const statusColors = {
    pending: "border-muted",
    verified: "border-green-500 bg-green-50 dark:bg-green-950/20",
    warning: "border-amber-500 bg-amber-50 dark:bg-amber-950/20",
    danger: "border-destructive bg-destructive/10",
  }

const StatusIcon = {
    pending: () => <div className="h-4 w-4 rounded-full border-2 border-muted-foreground/30 animate-pulse" />,
    verified: () => <ShieldCheck className="h-4 w-4 text-green-600" />,
    warning: () => <AlertTriangle className="h-4 w-4 text-amber-600" />,
    danger: () => <ShieldAlert className="h-4 w-4 text-destructive" />,
  }

return (
    <div className={cn("rounded-lg border p-3 space-y-2", statusColors[verificationStatus])}>
      <div className="flex items-center justify-between">
        <div className="flex items-center gap-2">
          {StatusIcon[verificationStatus]()}
          <span className="text-sm font-medium">{label || "Recipient Address"}</span>
        </div>
        <button onClick={copyAddress} className="text-muted-foreground hover:text-foreground">
          {copied ? <Check className="h-4 w-4 text-green-600" /> : <Copy className="h-4 w-4" />}
        </button>
      </div>
      
      <div className="font-mono text-sm break-all">{address}</div>
      
      {showWarnings && warnings.length > 0 && (
        <div className="space-y-1 pt-2 border-t border-border/50">
          {warnings.map((warning, i) => (
            <p key={i} className="text-xs text-amber-700 dark:text-amber-400 flex items-start gap-1.5">
              <AlertTriangle className="h-3 w-3 mt-0.5 shrink-0" />
              {warning}
            </p>
          ))}
        </div>
      )}
    </div>
  )
}

// URL safety checker
export function checkUrlSafety(url: string): { safe: boolean; reason?: string } {
  try {
    const parsed = new URL(url)
    const domain = parsed.hostname.toLowerCase()

// Check against known phishing domains
    if (KNOWN_PHISHING_DOMAINS.some(d => domain.includes(d))) {
      return { safe: false, reason: "Known phishing domain" }
    }

// Check against suspicious patterns
    for (const pattern of SUSPICIOUS_PATTERNS) {
      if (pattern.test(url)) {
        return { safe: false, reason: "URL matches suspicious pattern" }
      }
    }

// Check for suspicious TLDs
    const suspiciousTlds = [".tk", ".ml", ".ga", ".cf", ".gq"]
    if (suspiciousTlds.some(tld => domain.endsWith(tld))) {
      return { safe: false, reason: "Suspicious top-level domain" }
    }

// Check for punycode (internationalized domain names often used in phishing)
    if (domain.startsWith("xn--")) {
      return { safe: false, reason: "Internationalized domain name - verify carefully" }
    }

return { safe: true }
  } catch {
    return { safe: false, reason: "Invalid URL format" }
  }
}

// Site verification banner
export function SiteVerificationBanner() {
  const [isVerified, setIsVerified] = useState(true) // Default to verified to avoid flash
  const [showDetails, setShowDetails] = useState(false)
  const [mounted, setMounted] = useState(false)
  const [hostname, setHostname] = useState("")

useEffect(() => {
    setMounted(true)
    // Check if we're on the legitimate domain
    if (typeof window !== "undefined") {
      const currentHostname = window.location.hostname
      setHostname(currentHostname)
      const legitimateDomains = [
        "linkficrypto.com", 
        "www.linkficrypto.com", 
        "localhost",
        // Allow Vercel preview deployments
        "vercel.app"
      ]
      const isLegit = legitimateDomains.some(domain => 
        currentHostname === domain || currentHostname.endsWith(`.${domain}`)
      )
      setIsVerified(isLegit)
    }
  }, [])

// Don't render anything until mounted (avoids hydration issues)
  if (!mounted) return null

if (!isVerified) {
    return (
      <div className="fixed top-0 left-0 right-0 z-50 bg-destructive text-destructive-foreground py-2 px-4">
        <div className="max-w-screen-xl mx-auto flex items-center justify-center gap-2 text-sm">
          <ShieldAlert className="h-4 w-4" />
          <span className="font-medium">
            Warning: You may be on a phishing site. The official domain is linkficrypto.com
          </span>
        </div>
      </div>
    )
  }

return (
    <div className="fixed bottom-4 right-4 z-40">
      <button
        onClick={() => setShowDetails(!showDetails)}
        className="bg-green-600 text-white p-2 rounded-full shadow-lg hover:bg-green-700 transition-colors"
        title="Site verified"
      >
        <ShieldCheck className="h-5 w-5" />
      </button>
      
      {showDetails && (
        <div className="absolute bottom-12 right-0 bg-white dark:bg-gray-900 border rounded-lg shadow-xl p-4 w-72">
          <div className="flex items-center gap-2 mb-2">
            <ShieldCheck className="h-5 w-5 text-green-600" />
            <span className="font-medium">Verified Site</span>
          </div>
          <p className="text-sm text-muted-foreground">
            You are on the official LinkFiCrypto website. Always check for the padlock icon and verify the URL.
          </p>
          <div className="mt-3 pt-3 border-t">
            <p className="text-xs text-muted-foreground">
              Domain: {hostname}
            </p>
          </div>
        </div>
      )}
    </div>
  )
}
[V0_FILE]typescript:file="app/api/admin/commission-stats/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"
import { COMMISSION_WALLET_ADDRESS, COMMISSION_RATE } from "@/lib/commission-config"
import { ethers } from "ethers"

export async function GET() {
  try {
    const cookieStore = await cookies()
    const supabase = createServerClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.SUPABASE_SERVICE_ROLE_KEY!,
      {
        cookies: {
          getAll() {
            return cookieStore.getAll()
          },
          setAll(cookiesToSet) {
            try {
              cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
            } catch {}
          },
        },
      }
    )

// Get commission earnings from the commission_earnings table
    const { data: allCommissions } = await supabase
      .from("commission_earnings")
      .select("commission_amount, status, created_at, token")
      .order("created_at", { ascending: false })

// ALSO get transactions to calculate commissions from them
    // This handles cases where commission_earnings wasn't populated
    const { data: allTransactions } = await supabase
      .from("transactions")
      .select("amount, commission_amount, created_at, token, type, status")
      .order("created_at", { ascending: false })

// Calculate commissions from commission_earnings table
    const commissionsFromTable = allCommissions?.reduce(
      (sum, c) => sum + Number.parseFloat(c.commission_amount || "0"),
      0
    ) || 0

// Calculate commissions from transactions table (1% of each transaction amount)
    // This handles transactions that occurred before commission_earnings was populated
    const commissionsFromTransactions = allTransactions?.reduce((sum, tx) => {
      // Use stored commission_amount if available, otherwise calculate 1% of amount
      if (tx.commission_amount) {
        return sum + Number.parseFloat(tx.commission_amount)
      }
      // Calculate 1% commission on send transactions
      if (tx.type === "send" && tx.amount) {
        return sum + (Number.parseFloat(tx.amount) * COMMISSION_RATE)
      }
      return sum
    }, 0) || 0

// Use the higher value (in case some commissions are in both places)
    const totalEarned = Math.max(commissionsFromTable, commissionsFromTransactions)
    const transactionCount = allTransactions?.length || 0

const paidCommissions = allCommissions?.filter((c) => c.status === "paid") || []
    const pendingCommissions = allCommissions?.filter((c) => c.status === "pending" || c.status === "earned") || []
    const failedCommissions = allCommissions?.filter((c) => c.status === "failed") || []

// If no commission records exist but transactions do, all are "pending"
    const totalPaid = paidCommissions.reduce(
      (sum, c) => sum + Number.parseFloat(c.commission_amount || "0"),
      0
    )
    
    // Calculate pending: either from commission table or from transactions
    let totalPending = pendingCommissions.reduce(
      (sum, c) => sum + Number.parseFloat(c.commission_amount || "0"),
      0
    )
    
    // If commission_earnings is empty but we have transactions, count those as pending
    if (totalPending === 0 && commissionsFromTransactions > 0 && paidCommissions.length === 0) {
      totalPending = commissionsFromTransactions
    }
    
    const totalFailed = failedCommissions.reduce(
      (sum, c) => sum + Number.parseFloat(c.commission_amount || "0"),
      0
    )

// Get today's commissions (from transactions if commission_earnings is empty)
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    
    const todayTransactions = allTransactions?.filter(
      (tx) => new Date(tx.created_at) >= today && tx.type === "send"
    ) || []
    const todayEarned = todayTransactions.reduce((sum, tx) => {
      if (tx.commission_amount) return sum + Number.parseFloat(tx.commission_amount)
      return sum + (Number.parseFloat(tx.amount || "0") * COMMISSION_RATE)
    }, 0)

// Get this week's commissions
    const weekAgo = new Date()
    weekAgo.setDate(weekAgo.getDate() - 7)
    const weekTransactions = allTransactions?.filter(
      (tx) => new Date(tx.created_at) >= weekAgo && tx.type === "send"
    ) || []
    const weekEarned = weekTransactions.reduce((sum, tx) => {
      if (tx.commission_amount) return sum + Number.parseFloat(tx.commission_amount)
      return sum + (Number.parseFloat(tx.amount || "0") * COMMISSION_RATE)
    }, 0)

// Get commission wallet balance from blockchain
    let walletBalance = "0"
    let walletBalanceUsd = "0"
    let ethPrice = 3000

try {
      const rpcUrl = process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL
      if (rpcUrl) {
        const provider = new ethers.JsonRpcProvider(rpcUrl)
        const balance = await provider.getBalance(COMMISSION_WALLET_ADDRESS)
        walletBalance = ethers.formatEther(balance)

// Get ETH price
        try {
          const priceRes = await fetch(
            "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd"
          )
          const priceData = await priceRes.json()
          ethPrice = priceData.ethereum?.usd || 3000
          walletBalanceUsd = (Number.parseFloat(walletBalance) * ethPrice).toFixed(2)
        } catch {
          walletBalanceUsd = (Number.parseFloat(walletBalance) * 3000).toFixed(2)
        }
      }
    } catch (error) {
      console.error("[v0] Error fetching wallet balance:", error)
    }

// Get recent payouts
    const { data: recentPayouts } = await supabase
      .from("commission_payouts")
      .select("*")
      .order("created_at", { ascending: false })
      .limit(5)

// Get commission by day for chart (last 7 days) - calculate from transactions
    const commissionByDay: { date: string; amount: number }[] = []
    for (let i = 6; i >= 0; i--) {
      const date = new Date()
      date.setDate(date.getDate() - i)
      date.setHours(0, 0, 0, 0)
      const nextDate = new Date(date)
      nextDate.setDate(nextDate.getDate() + 1)

// Calculate from transactions for this day
      const dayTransactions = allTransactions?.filter((tx) => {
        const txDate = new Date(tx.created_at)
        return txDate >= date && txDate < nextDate && tx.type === "send"
      }) || []

const dayTotal = dayTransactions.reduce((sum, tx) => {
        if (tx.commission_amount) return sum + Number.parseFloat(tx.commission_amount)
        return sum + (Number.parseFloat(tx.amount || "0") * COMMISSION_RATE)
      }, 0)

commissionByDay.push({
        date: date.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
        amount: dayTotal,
      })
    }

return NextResponse.json({
      wallet: {
        address: COMMISSION_WALLET_ADDRESS,
        shortAddress: `${COMMISSION_WALLET_ADDRESS.slice(0, 6)}...${COMMISSION_WALLET_ADDRESS.slice(-4)}`,
        balance: walletBalance,
        balanceUsd: walletBalanceUsd,
        isValid: /^0x[a-fA-F0-9]{40}$/.test(COMMISSION_WALLET_ADDRESS),
      },
      stats: {
        totalEarned: totalEarned.toFixed(8),
        totalEarnedUsd: (totalEarned * ethPrice).toFixed(2),
        totalPaid: totalPaid.toFixed(8),
        totalPaidUsd: (totalPaid * ethPrice).toFixed(2),
        totalPending: totalPending.toFixed(8),
        totalPendingUsd: (totalPending * ethPrice).toFixed(2),
        totalFailed: totalFailed.toFixed(8),
        todayEarned: todayEarned.toFixed(8),
        todayEarnedUsd: (todayEarned * ethPrice).toFixed(2),
        weekEarned: weekEarned.toFixed(8),
        weekEarnedUsd: (weekEarned * ethPrice).toFixed(2),
        transactionCount: transactionCount,
        paidCount: paidCommissions.length,
        pendingCount: pendingCommissions.length,
        failedCount: failedCommissions.length,
      },
      rate: {
        current: COMMISSION_RATE,
        percent: COMMISSION_RATE * 100,
      },
      ethPrice,
      recentPayouts: recentPayouts || [],
      chartData: commissionByDay,
    })
  } catch (error: any) {
    console.error("[v0] Error fetching commission stats:", error)
    return NextResponse.json({ error: error.message }, { status: 500 })
  }
}
[V0_FILE]typescriptreact:file="app/admin/settings/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { AdminLayout } from "@/components/admin-layout"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Button } from "@/components/ui/button"
import { Badge } from "@/components/ui/badge"
import { createClient } from "@/lib/supabase/client"
import {
  Copy,
  Check,
  Save,
  CheckCircle,
  XCircle,
  AlertCircle,
  Wallet,
  ExternalLink,
  RefreshCw,
  TrendingUp,
  DollarSign,
  ArrowUpRight,
} from "lucide-react"
import { COMMISSION_WALLET_ADDRESS, getCommissionWalletInfo } from "@/lib/commission-config"

export default function AdminSettingsPage() {
  const [copied, setCopied] = useState(false)
  const [settings, setSettings] = useState({
    commissionRate: "0.5",
    minCommission: "0.00001",
    platformName: "LinkFi Crypto",
  })
  const [loading, setLoading] = useState(false)
  const [saved, setSaved] = useState(false)
  const [networkStatus, setNetworkStatus] = useState<{
    rpcConfigured: boolean
    networkName: string | null
    walletValid: boolean
  }>({
    rpcConfigured: false,
    networkName: null,
    walletValid: false,
  })
  const [walletStats, setWalletStats] = useState({
    balance: "0",
    balanceUsd: "0",
    totalCommissions: "0",
    pendingCommissions: "0",
    paidCommissions: "0",
    loading: true,
  })
  const walletInfo = getCommissionWalletInfo()

useEffect(() => {
    loadSettings()
    checkNetworkConfiguration()
    loadWalletStats()
  }, [])

const loadWalletStats = async () => {
    try {
      const response = await fetch("/api/admin/commission-stats")
      if (response.ok) {
        const data = await response.json()
        setWalletStats({
          balance: data.wallet?.balance || "0",
          balanceUsd: data.wallet?.balanceUsd || "0",
          totalCommissions: data.stats?.totalCommissions || "0",
          pendingCommissions: data.stats?.pendingCommissions || "0",
          paidCommissions: data.stats?.paidCommissions || "0",
          loading: false,
        })
      }
    } catch (error) {
      console.error("Failed to load wallet stats:", error)
      setWalletStats((prev) => ({ ...prev, loading: false }))
    }
  }

const checkNetworkConfiguration = async () => {
    try {
      const rpcConfigured = !!process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL
      const rpcUrl = process.env.NEXT_PUBLIC_MAINNET_RPC_URL

setNetworkStatus({
        rpcConfigured,
        networkName: rpcUrl?.includes("sepolia")
          ? "Sepolia Testnet"
          : rpcConfigured
            ? "Ethereum Mainnet"
            : "Ethereum Mainnet",
        walletValid:
          COMMISSION_WALLET_ADDRESS &&
          COMMISSION_WALLET_ADDRESS.startsWith("0x") &&
          COMMISSION_WALLET_ADDRESS.length === 42,
      })
    } catch (error) {
      console.error("Failed to check network configuration:", error)
    }
  }

const loadSettings = async () => {
    try {
      const supabase = createClient()

const { data, error } = await supabase.from("admin_settings").select("*")

if (error) throw error

if (data && data.length > 0) {
        const settingsMap: { [key: string]: string } = {}
        data.forEach((item: { setting_key: string; setting_value: string }) => {
          settingsMap[item.setting_key] = item.setting_value
        })

setSettings({
          commissionRate: settingsMap.commission_rate || "0.5",
          minCommission: settingsMap.min_commission || "0.00001",
          platformName: settingsMap.platform_name || "LinkFi Crypto",
        })
      }
    } catch (error) {
      console.error("Failed to load settings:", error)
    }
  }

const handleSaveSettings = async () => {
    setLoading(true)
    setSaved(false)

try {
      const supabase = createClient()

const updates = [
        { setting_key: "commission_rate", setting_value: settings.commissionRate, description: "Commission rate (%)" },
        {
          setting_key: "min_commission",
          setting_value: settings.minCommission,
          description: "Minimum commission amount (ETH)",
        },
        { setting_key: "platform_name", setting_value: settings.platformName, description: "Platform name" },
      ]

for (const update of updates) {
        await supabase.from("admin_settings").upsert(update, { onConflict: "setting_key" })
      }

setSaved(true)
      setTimeout(() => setSaved(false), 3000)
    } catch (error) {
      console.error("Failed to save settings:", error)
    } finally {
      setLoading(false)
    }
  }

const copyToClipboard = (text: string) => {
    navigator.clipboard.writeText(text)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

return (
    <AdminLayout>
      <div className="space-y-6">
        <div>
          <h1 className="text-3xl font-bold text-gray-900">Settings</h1>
          <p className="text-gray-600 mt-1">Manage your platform settings and configuration</p>
        </div>

<Card className="border-2">
          <CardHeader>
            <CardTitle className="flex items-center gap-2">
              Network Configuration Status
              {networkStatus.rpcConfigured && networkStatus.walletValid ? (
                <CheckCircle className="w-5 h-5 text-green-500" />
              ) : (
                <AlertCircle className="w-5 h-5 text-amber-500" />
              )}
            </CardTitle>
            <CardDescription>Verify your blockchain and commission wallet setup</CardDescription>
          </CardHeader>
          <CardContent className="space-y-4">
            <div className="grid gap-4 md:grid-cols-2">
              <div className="space-y-2 p-4 bg-gray-50 rounded-lg">
                <div className="flex items-center justify-between">
                  <Label className="text-sm font-medium">RPC URL Status</Label>
                  {networkStatus.rpcConfigured ? (
                    <CheckCircle className="w-4 h-4 text-green-500" />
                  ) : (
                    <XCircle className="w-4 h-4 text-red-500" />
                  )}
                </div>
                <p className="text-xs text-gray-600">
                  {networkStatus.rpcConfigured ? (
                    <>
                      <span className="font-mono text-green-700">Configured</span>
                      <br />
                      Network: <span className="font-semibold">{networkStatus.networkName}</span>
                    </>
                  ) : (
                    <span className="text-red-600">
                      Not configured - Add NEXT_PUBLIC_SEPOLIA_RPC_URL to environment variables
                    </span>
                  )}
                </p>
              </div>

<div className="space-y-2 p-4 bg-gray-50 rounded-lg">
                <div className="flex items-center justify-between">
                  <Label className="text-sm font-medium">Commission Wallet</Label>
                  {networkStatus.walletValid ? (
                    <CheckCircle className="w-4 h-4 text-green-500" />
                  ) : (
                    <XCircle className="w-4 h-4 text-red-500" />
                  )}
                </div>
                <p className="text-xs text-gray-600">
                  {networkStatus.walletValid ? (
                    <>
                      <span className="font-mono text-green-700 block truncate">{COMMISSION_WALLET_ADDRESS}</span>
                      <span className="text-green-700 font-medium">Valid Ethereum address</span>
                    </>
                  ) : (
                    <span className="text-red-600">Invalid wallet address format</span>
                  )}
                </p>
              </div>
            </div>

{networkStatus.rpcConfigured && networkStatus.walletValid ? (
              <div className="bg-green-50 border border-green-200 rounded-lg p-4">
                <p className="text-sm text-green-800 font-medium mb-1">✓ Setup Complete</p>
                <p className="text-xs text-green-700">
                  Your commission system is properly configured. Commissions will accumulate and can be paid out to{" "}
                  <span className="font-mono">
                    {COMMISSION_WALLET_ADDRESS.slice(0, 10)}...{COMMISSION_WALLET_ADDRESS.slice(-8)}
                  </span>
                </p>
              </div>
            ) : (
              <div className="bg-amber-50 border border-amber-200 rounded-lg p-4">
                <p className="text-sm text-amber-800 font-medium mb-2">⚠ Configuration Required</p>
                <ul className="text-xs text-amber-700 space-y-1 list-disc list-inside">
                  {!networkStatus.rpcConfigured && (
                    <li>Add NEXT_PUBLIC_SEPOLIA_RPC_URL to your environment variables</li>
                  )}
                  {!networkStatus.walletValid && (
                    <li>Configure a valid commission wallet address in lib/commission-config.ts</li>
                  )}
                </ul>
              </div>
            )}
          </CardContent>
        </Card>

<div className="grid gap-6 md:grid-cols-2">
          <Card>
            <CardHeader>
              <CardTitle>Commission Settings</CardTitle>
              <CardDescription>Configure commission rates and thresholds</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="commissionRate">Commission Rate (%)</Label>
                <Input
                  id="commissionRate"
                  type="number"
                  step="0.1"
                  value={settings.commissionRate}
                  onChange={(e) => setSettings({ ...settings, commissionRate: e.target.value })}
                  placeholder="0.5"
                />
                <p className="text-xs text-gray-500">Percentage of gas fees collected as commission</p>
              </div>

<div className="space-y-2">
                <Label htmlFor="minCommission">Minimum Commission (ETH)</Label>
                <Input
                  id="minCommission"
                  type="number"
                  step="0.00001"
                  value={settings.minCommission}
                  onChange={(e) => setSettings({ ...settings, minCommission: e.target.value })}
                  placeholder="0.00001"
                />
                <p className="text-xs text-gray-500">Minimum commission amount before payout</p>
              </div>

<Button onClick={handleSaveSettings} disabled={loading} className="w-full">
                {saved ? (
                  <>
                    <Check className="w-4 h-4 mr-2" />
                    Saved
                  </>
                ) : (
                  <>
                    <Save className="w-4 h-4 mr-2" />
                    {loading ? "Saving..." : "Save Settings"}
                  </>
                )}
              </Button>
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Platform Settings</CardTitle>
              <CardDescription>General platform configuration</CardDescription>
            </CardHeader>
            <CardContent className="space-y-4">
              <div className="space-y-2">
                <Label htmlFor="platformName">Platform Name</Label>
                <Input
                  id="platformName"
                  type="text"
                  value={settings.platformName}
                  onChange={(e) => setSettings({ ...settings, platformName: e.target.value })}
                  placeholder="LinkFi Crypto"
                />
                <p className="text-xs text-gray-500">Display name for your platform</p>
              </div>

<div className="space-y-2">
                <Label>Commission Wallet Address</Label>
                <div className="flex gap-2">
                  <Input value={COMMISSION_WALLET_ADDRESS} readOnly className="font-mono text-sm" />
                  <Button
                    variant="outline"
                    size="icon"
                    onClick={() => copyToClipboard(COMMISSION_WALLET_ADDRESS)}
                    className="shrink-0"
                  >
                    {copied ? <Check className="w-4 h-4" /> : <Copy className="w-4 h-4" />}
                  </Button>
                </div>
                <p className="text-xs text-gray-500">Your 1inch wallet for receiving commissions</p>
              </div>
            </CardContent>
          </Card>
        </div>

<Card>
          <CardHeader>
            <CardTitle>Environment Configuration</CardTitle>
            <CardDescription>Required environment variables for your deployment</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-4">
              <div className="bg-gray-50 p-4 rounded-lg space-y-3">
                <div className="space-y-1">
                  <p className="text-sm font-medium text-gray-900">NEXT_PUBLIC_SEPOLIA_RPC_URL</p>
                  <p className="text-xs text-gray-600">
                    Ethereum RPC endpoint for blockchain transactions
                    {networkStatus.rpcConfigured && (
                      <span className="ml-2 text-green-600 font-medium">✓ Configured</span>
                    )}
                  </p>
                  <div className="bg-white p-2 rounded border border-gray-200">
                    <p className="text-xs font-mono text-gray-900">Variable name: NEXT_PUBLIC_SEPOLIA_RPC_URL</p>
                    <p className="text-xs text-gray-500 mt-1">
                      Add this variable in Vercel project settings with your RPC endpoint from Alchemy or Infura
                    </p>
                  </div>
                </div>

<div className="space-y-1">
                  <p className="text-sm font-medium text-gray-900">ADMIN_PASSWORD</p>
                  <p className="text-xs text-gray-600">Your admin panel login password</p>
                  <code className="block bg-white p-2 rounded text-xs font-mono border border-gray-200">
                    ADMIN_PASSWORD=your_secure_password_here
                  </code>
                </div>

<div className="space-y-1">
                  <p className="text-sm font-medium text-gray-900">Database Configuration</p>
                  <p className="text-xs text-gray-600">
                    Supabase credentials <span className="text-green-600 font-medium">✓ Configured</span>
                  </p>
                  <code className="block bg-white p-2 rounded text-xs font-mono border border-gray-200">
                    NEXT_PUBLIC_SUPABASE_URL=*** (configured)
                    <br />
                    NEXT_PUBLIC_SUPABASE_ANON_KEY=*** (configured)
                  </code>
                </div>
              </div>

<div className="bg-blue-50 border border-blue-200 rounded-lg p-4">
                <p className="text-sm text-blue-800 font-medium mb-2">How to configure RPC URL:</p>
                <ol className="text-xs text-blue-700 space-y-1 list-decimal list-inside">
                  <li>Sign up for a free account at Alchemy (alchemy.com) or Infura (infura.io)</li>
                  <li>Create a new app/project and get your API key</li>
                  <li>Add the RPC URL to environment variables in your Vercel project settings</li>
                  <li>For production: Use Ethereum mainnet endpoint</li>
                  <li>Set it as NEXT_PUBLIC_MAINNET_RPC_URL</li>
                  <li>Redeploy your application after adding the variable</li>
                </ol>
              </div>
            </div>
          </CardContent>
        </Card>
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescriptreact:file="app/admin/page.tsx" isMerged="true"
"use client"

import { useEffect, useState } from "react"
import { AdminLayout } from "@/components/admin-layout"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import {
  Users,
  DollarSign,
  ArrowLeftRight,
  TrendingUp,
  Wallet,
  Activity,
  BarChart3,
  Key,
  CheckCircle,
  ExternalLink,
  Copy,
  Check,
  RefreshCw,
} from "lucide-react"
import { COMMISSION_RATE, COMMISSION_WALLET_ADDRESS } from "@/lib/commission-config"

// Helper to shorten wallet address
function shortenAddress(address: string): string {
  if (!address) return ""
  return `${address.slice(0, 6)}...${address.slice(-4)}`
}

export default function AdminDashboard() {
  const [stats, setStats] = useState({
    totalUsers: 0,
    totalTransactions: 0,
    totalCommissions: "0",
    recentTransactions: 0,
    totalVolume: "0",
    avgTransactionValue: "0",
  })
  const [loading, setLoading] = useState(true)
  const [recentActivity, setRecentActivity] = useState<any[]>([])
  const [walletBalance, setWalletBalance] = useState({ balance: "0", balanceUsd: "0" })
  const [copied, setCopied] = useState(false)

useEffect(() => {
    loadDashboardStats()
    loadWalletBalance()
  }, [])

const loadWalletBalance = async () => {
    try {
      const response = await fetch("/api/admin/commission-stats")
      if (response.ok) {
        const data = await response.json()
        setWalletBalance({
          balance: data.wallet?.balance || "0",
          balanceUsd: data.wallet?.balanceUsd || "0",
        })
      }
    } catch (error) {
      console.error("Failed to load wallet balance:", error)
    }
  }

const copyToClipboard = (text: string) => {
    navigator.clipboard.writeText(text)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

const loadDashboardStats = async () => {
    try {
      const response = await fetch("/api/admin/stats")
      if (!response.ok) {
        throw new Error("Failed to load stats")
      }
      const data = await response.json()

setStats({
        totalUsers: data.totalUsers,
        totalTransactions: data.totalTransactions,
        totalCommissions: data.totalCommissions,
        recentTransactions: data.recentTransactions,
        totalVolume: data.totalVolume,
        avgTransactionValue: data.avgTransactionValue,
      })
      setRecentActivity(data.recentActivity)
    } catch (error) {
      console.error("Failed to load dashboard stats:", error)
    } finally {
      setLoading(false)
    }
  }

const statCards = [
    {
      title: "Total Users",
      value: stats.totalUsers,
      description: "Registered users",
      icon: Users,
      color: "text-blue-600",
      bgColor: "bg-blue-50",
      border: "border-blue-200",
    },
    {
      title: "Total Transactions",
      value: stats.totalTransactions,
      description: "All time",
      icon: ArrowLeftRight,
      color: "text-green-600",
      bgColor: "bg-green-50",
      border: "border-green-200",
    },
    {
      title: "Total Commissions",
      value: `${stats.totalCommissions} ETH`,
      description: `${COMMISSION_RATE * 100}% commission earned`,
      icon: DollarSign,
      color: "text-purple-600",
      bgColor: "bg-purple-50",
      border: "border-purple-200",
    },
    {
      title: "Recent Activity",
      value: stats.recentTransactions,
      description: "Last 24 hours",
      icon: TrendingUp,
      color: "text-orange-600",
      bgColor: "bg-orange-50",
      border: "border-orange-200",
    },
    {
      title: "Total Volume",
      value: `${stats.totalVolume} ETH`,
      description: "Transaction volume",
      icon: Wallet,
      color: "text-cyan-600",
      bgColor: "bg-cyan-50",
      border: "border-cyan-200",
    },
    {
      title: "Avg Transaction",
      value: `${stats.avgTransactionValue} ETH`,
      description: "Average value",
      icon: BarChart3,
      color: "text-pink-600",
      bgColor: "bg-pink-50",
      border: "border-pink-200",
    },
  ]

const formatDate = (dateString: string) => {
    const date = new Date(dateString)
    return date.toLocaleString("en-US", {
      month: "short",
      day: "numeric",
      hour: "2-digit",
      minute: "2-digit",
    })
  }

const shortenAddress = (address: string) => {
    return `${address.slice(0, 6)}...${address.slice(-4)}`
  }

return (
    <AdminLayout>
      <div className="space-y-8">
        <div>
          <h1 className="text-3xl font-bold text-gray-900">Admin Dashboard</h1>
          <p className="text-gray-600 mt-1">Welcome to LinkFiCrypto admin panel</p>
        </div>

{/* Commission Wallet Status */}
        <Card className="border-2 border-green-200 bg-gradient-to-r from-green-50 to-emerald-50">
          <CardHeader className="pb-2">
            <CardTitle className="flex items-center gap-2 text-green-900">
              <Wallet className="w-5 h-5" />
              Commission Wallet
              <CheckCircle className="w-4 h-4 text-green-500" />
            </CardTitle>
            <CardDescription className="text-green-700">
              Commissions are automatically sent to this wallet
            </CardDescription>
          </CardHeader>
          <CardContent>
            <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
              <div className="space-y-1">
                <div className="flex items-center gap-2">
                  <code className="text-lg font-mono font-bold text-green-900">
                    {shortenAddress(COMMISSION_WALLET_ADDRESS)}
                  </code>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="h-8 w-8 p-0"
                    onClick={() => copyToClipboard(COMMISSION_WALLET_ADDRESS)}
                  >
                    {copied ? (
                      <Check className="h-4 w-4 text-green-600" />
                    ) : (
                      <Copy className="h-4 w-4 text-green-600" />
                    )}
                  </Button>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="h-8 w-8 p-0"
                    onClick={() =>
                      window.open(
                        `https://etherscan.io/address/${COMMISSION_WALLET_ADDRESS}`,
                        "_blank"
                      )
                    }
                  >
                    <ExternalLink className="h-4 w-4 text-green-600" />
                  </Button>
                </div>
                <p className="text-sm text-green-700">Your 1inch wallet for receiving commissions</p>
              </div>
              <div className="text-right">
                <div className="text-2xl font-bold text-green-900">
                  {Number.parseFloat(walletBalance.balance).toFixed(6)} ETH
                </div>
                <p className="text-sm text-green-700">${walletBalance.balanceUsd} USD</p>
              </div>
            </div>
          </CardContent>
        </Card>

{loading ? (
          <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-6">
            {[1, 2, 3, 4, 5, 6].map((i) => (
              <Card key={i} className="animate-pulse">
                <CardHeader className="pb-2">
                  <div className="h-4 bg-gray-200 rounded w-24" />
                </CardHeader>
                <CardContent>
                  <div className="h-8 bg-gray-200 rounded w-16 mb-2" />
                  <div className="h-3 bg-gray-200 rounded w-20" />
                </CardContent>
              </Card>
            ))}
          </div>
        ) : (
          <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-6">
            {statCards.map((stat) => (
              <Card key={stat.title} className={`border-l-4 ${stat.border} hover:shadow-md transition-shadow`}>
                <CardHeader className="flex flex-row items-center justify-between pb-2">
                  <CardTitle className="text-sm font-medium text-gray-700">{stat.title}</CardTitle>
                  <div className={`p-2.5 rounded-xl ${stat.bgColor}`}>
                    <stat.icon className={`w-5 h-5 ${stat.color}`} />
                  </div>
                </CardHeader>
                <CardContent>
                  <div className="text-2xl font-bold text-gray-900">{stat.value}</div>
                  <p className="text-xs text-gray-500 mt-1">{stat.description}</p>
                </CardContent>
              </Card>
            ))}
          </div>
        )}

<div className="grid grid-cols-1 xl:grid-cols-2 gap-6">
          <Card>
            <CardHeader>
              <CardTitle className="flex items-center gap-2">
                <Activity className="w-5 h-5 text-blue-600" />
                Recent Activity
              </CardTitle>
              <CardDescription>Latest transactions on the platform</CardDescription>
            </CardHeader>
            <CardContent>
              {recentActivity.length === 0 ? (
                <p className="text-gray-500 text-center py-8">No recent activity</p>
              ) : (
                <div className="space-y-4">
                  {recentActivity.map((tx) => (
                    <div key={tx.id} className="flex items-center justify-between p-3 bg-gray-50 rounded-lg">
                      <div className="flex-1">
                        <div className="flex items-center gap-2">
                          <span className="text-sm font-medium text-gray-900">
                            {Number.parseFloat(tx.amount).toFixed(4)} {tx.token || "ETH"}
                          </span>
                          <span
                            className={`text-xs px-2 py-0.5 rounded-full ${
                              tx.status === "confirmed"
                                ? "bg-green-100 text-green-700"
                                : tx.status === "pending"
                                  ? "bg-yellow-100 text-yellow-700"
                                  : "bg-red-100 text-red-700"
                            }`}
                          >
                            {tx.status}
                          </span>
                        </div>
                        <p className="text-xs text-gray-500 mt-1">
                          {shortenAddress(tx.from_address)} → {shortenAddress(tx.to_address)}
                        </p>
                      </div>
                      <span className="text-xs text-gray-400">{formatDate(tx.created_at)}</span>
                    </div>
                  ))}
                </div>
              )}
            </CardContent>
          </Card>

<Card>
            <CardHeader>
              <CardTitle>Quick Actions</CardTitle>
              <CardDescription>Manage your crypto platform</CardDescription>
            </CardHeader>
            <CardContent>
              <div className="grid grid-cols-1 gap-3">
                <a
                  href="/admin/wallet-recovery"
                  className="flex items-center gap-3 p-4 border-2 border-orange-200 rounded-xl hover:border-orange-400 hover:bg-orange-50 transition-all"
                >
                  <div className="p-2 bg-orange-100 rounded-lg">
                    <Key className="w-6 h-6 text-orange-600" />
                  </div>
                  <div>
                    <h3 className="font-semibold text-gray-900">Recover Wallet Key</h3>
                    <p className="text-sm text-gray-600">Export your private key for commission payouts</p>
                  </div>
                </a>

<a
                  href="/admin/users"
                  className="flex items-center gap-3 p-4 border-2 border-gray-200 rounded-xl hover:border-blue-300 hover:bg-blue-50 transition-all"
                >
                  <div className="p-2 bg-blue-100 rounded-lg">
                    <Users className="w-6 h-6 text-blue-600" />
                  </div>
                  <div>
                    <h3 className="font-semibold text-gray-900">Manage Users</h3>
                    <p className="text-sm text-gray-600">View and manage user accounts</p>
                  </div>
                </a>

<a
                  href="/admin/transactions"
                  className="flex items-center gap-3 p-4 border-2 border-gray-200 rounded-xl hover:border-green-300 hover:bg-green-50 transition-all"
                >
                  <div className="p-2 bg-green-100 rounded-lg">
                    <ArrowLeftRight className="w-6 h-6 text-green-600" />
                  </div>
                  <div>
                    <h3 className="font-semibold text-gray-900">View Transactions</h3>
                    <p className="text-sm text-gray-600">Monitor all platform transactions</p>
                  </div>
                </a>
                <a
                  href="/admin/commissions"
                  className="flex items-center gap-3 p-4 border-2 border-gray-200 rounded-xl hover:border-purple-300 hover:bg-purple-50 transition-all"
                >
                  <div className="p-2 bg-purple-100 rounded-lg">
                    <DollarSign className="w-6 h-6 text-purple-600" />
                  </div>
                  <div>
                    <h3 className="font-semibold text-gray-900">Track Commissions</h3>
                    <p className="text-sm text-gray-600">View commission earnings</p>
                  </div>
                </a>
              </div>
            </CardContent>
          </Card>
        </div>
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescript:file="app/api/admin/commissions/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { createClient } from "@supabase/supabase-js"
import { COMMISSION_WALLET_ADDRESS, COMMISSION_RATE } from "@/lib/commission-config"

export async function GET() {
  try {
    const supabase = createClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.SUPABASE_SERVICE_ROLE_KEY!,
      {
        auth: {
          autoRefreshToken: false,
          persistSession: false,
        },
      }
    )

// Get commission earnings from commission_earnings table (preferred)
    const { data: commissionEarnings, error: earningsError } = await supabase
      .from("commission_earnings")
      .select("*")
      .order("created_at", { ascending: false })

// Get ALL transactions (not just those with commission_amount)
    // Calculate commission for transactions that don't have it stored
    const { data: transactions, error: txError } = await supabase
      .from("transactions")
      .select("*")
      .order("created_at", { ascending: false })

if (earningsError && txError) {
      console.error("[v0] Database errors:", earningsError, txError)
      throw earningsError || txError
    }

// Combine and deduplicate based on tx_hash
    const seenTxHashes = new Set<string>()
    const combinedCommissions: any[] = []

// Process commission earnings first (higher priority)
    for (const earning of commissionEarnings || []) {
      if (earning.tx_hash && !seenTxHashes.has(earning.tx_hash)) {
        seenTxHashes.add(earning.tx_hash)
        combinedCommissions.push({
          id: earning.id,
          tx_hash: earning.tx_hash,
          from_address: earning.metadata?.from_address || "Unknown",
          to_address: earning.metadata?.to_address || COMMISSION_WALLET_ADDRESS,
          amount: earning.amount,
          commission_amount: earning.commission_amount,
          token: earning.token || "ETH",
          status: earning.status,
          created_at: earning.created_at,
          commission_tx_hash: earning.metadata?.commission_tx_hash || null,
          commission_wallet: earning.commission_wallet || COMMISSION_WALLET_ADDRESS,
        })
      }
    }

// Add transactions not in commission_earnings
    // Calculate commission for transactions that don't have it stored
    for (const tx of transactions || []) {
      if (tx.tx_hash && !seenTxHashes.has(tx.tx_hash)) {
        seenTxHashes.add(tx.tx_hash)
        
        // Calculate commission: use stored value or calculate 1% of transaction amount
        let commissionAmount = tx.commission_amount
        if (!commissionAmount || Number.parseFloat(commissionAmount) === 0) {
          const txAmount = Number.parseFloat(tx.amount) || 0
          commissionAmount = (txAmount * COMMISSION_RATE).toFixed(8)
        }
        
        combinedCommissions.push({
          id: tx.id,
          tx_hash: tx.tx_hash,
          from_address: tx.from_address,
          to_address: tx.to_address,
          amount: tx.amount,
          commission_amount: commissionAmount,
          token: tx.token || "ETH",
          status: tx.status === "confirmed" ? "earned" : "pending", // Show as earned if confirmed
          created_at: tx.created_at,
          commission_tx_hash: null,
          commission_wallet: COMMISSION_WALLET_ADDRESS,
        })
      }
    }

// Sort by created_at descending
    combinedCommissions.sort(
      (a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
    )

// Calculate totals
    const total = combinedCommissions.reduce(
      (sum, c) => sum + Number.parseFloat(c.commission_amount?.toString() || "0"),
      0
    )

const paidTotal = combinedCommissions
      .filter((c) => c.status === "paid")
      .reduce((sum, c) => sum + Number.parseFloat(c.commission_amount?.toString() || "0"), 0)

const pendingTotal = combinedCommissions
      .filter((c) => c.status === "pending" || c.status === "earned")
      .reduce((sum, c) => sum + Number.parseFloat(c.commission_amount?.toString() || "0"), 0)

return NextResponse.json({
      commissions: combinedCommissions,
      total,
      paidTotal,
      pendingTotal,
      count: combinedCommissions.length,
      walletAddress: COMMISSION_WALLET_ADDRESS,
    })
  } catch (error) {
    console.error("[v0] Failed to load commissions:", error)
    return NextResponse.json({ error: "Failed to load commissions" }, { status: 500 })
  }
}
[V0_FILE]typescript:file="lib/gas-fee-calculator.ts" isMerged="true"
// Gas fee calculator with EIP-1559 support and commission system

import { COMMISSION_WALLET_ADDRESS, COMMISSION_RATE, MIN_COMMISSION_AMOUNT } from "./commission-config"

export type GasFeeSpeed = "low" | "market" | "aggressive"

export interface GasFeeOption {
  speed: GasFeeSpeed
  label: string
  icon: string
  maxFeePerGas: bigint // EIP-1559
  maxPriorityFeePerGas: bigint // EIP-1559
  gasLimit: bigint // Gas limit for the transaction
  estimatedTime: string
  totalCostEth: string // in ETH (including commission)
  totalCostUsd: string // in USD
  totalCost: string // total cost in ETH as string
  totalCostWei: string // total cost in Wei as string
  gasCostEth: string // gas cost only in ETH
  commission: string // in ETH
  commissionWei: string // commission in Wei
  description: string
}

export interface GasFeeCalculation {
  options: GasFeeOption[]
  selected: GasFeeSpeed
  commissionRate: number // percentage (e.g., 0.5 for 0.5%)
  ethPriceUsd: number
  baseFee: bigint
  priorityFee: bigint
}

// Standard gas limit for ETH transfer
const ETH_GAS_LIMIT = 21000n
// Higher gas limit for ERC-20 token transfers
const ERC20_GAS_LIMIT = 65000n

// Fetch current ETH price in USD
async function getEthPrice(): Promise<number> {
  try {
    const response = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd")
    const data = await response.json()
    return data.ethereum?.usd || 3000
  } catch (error) {
    console.error("[v0] Error fetching ETH price:", error)
    return 3000
  }
}

// Sleep helper for retry
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

// Get network gas data (baseFee + priority fee) with retry logic
async function getGasData(provider: any, retries = 3): Promise<{ baseFee: bigint; priorityFee: bigint }> {
  let lastError: any
  
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      // Get latest block for baseFee
      const block = await provider.request({
        method: "eth_getBlockByNumber",
        params: ["latest", false],
      })

const baseFee = BigInt(block.baseFeePerGas || "0x0")

// Get suggested priority fee (tip)
      let priorityFee: bigint
      try {
        const maxPriorityFee = await provider.request({
          method: "eth_maxPriorityFeePerGas",
          params: [],
        })
        priorityFee = BigInt(maxPriorityFee)
      } catch {
        priorityFee = 100_000_000n // 0.1 Gwei
      }

console.log("[v0] Network gas data - baseFee:", baseFee.toString(), "priorityFee:", priorityFee.toString())

return { baseFee, priorityFee }
    } catch (error: any) {
      lastError = error
      const isRateLimited = error?.code === 429 || 
        error?.message?.includes("rate-limit") ||
        error?.message?.includes("429")
      
      if (isRateLimited && attempt < retries - 1) {
        const delay = 1000 * Math.pow(2, attempt) + Math.random() * 500
        console.log(`[v0] Gas data fetch rate-limited, retrying in ${Math.round(delay)}ms...`)
        await sleep(delay)
        continue
      }
      
      console.error("[v0] Error fetching gas data:", error?.message?.slice(0, 100))
    }
  }
  
  // Return sensible defaults for Ethereum mainnet
  console.log("[v0] Using fallback gas data for Ethereum mainnet")
  return {
    baseFee: 20_000_000_000n, // 20 Gwei fallback for mainnet
    priorityFee: 1_500_000_000n, // 1.5 Gwei tip
  }
}

// Calculate gas presets like MetaMask
function calculateGasPresets(baseFee: bigint, priorityFee: bigint) {
  return {
    low: {
      maxPriorityFeePerGas: priorityFee / 2n, // 0.5x tip for low
      maxFeePerGas: baseFee + priorityFee / 2n, // 100% base + 0.5x tip
    },
    market: {
      maxPriorityFeePerGas: priorityFee,
      maxFeePerGas: baseFee + priorityFee, // 100% base + 1x tip (standard)
    },
    aggressive: {
      maxPriorityFeePerGas: priorityFee * 2n,
      maxFeePerGas: baseFee + priorityFee * 2n, // 100% base + 2x tip for fast
    },
  }
}

export async function calculateGasFees(
  provider: any,
  token = "ETH",
  commissionRate: number = COMMISSION_RATE,
): Promise<GasFeeCalculation> {
  try {
    // Get current ETH price and network gas data in parallel
    const [ethPriceUsd, gasData] = await Promise.all([getEthPrice(), getGasData(provider)])

const { baseFee, priorityFee } = gasData
    const presets = calculateGasPresets(baseFee, priorityFee)

const gasLimit = token === "ETH" ? ETH_GAS_LIMIT : ERC20_GAS_LIMIT

console.log(`[v0] Calculating gas fees for ${token} with gas limit:`, gasLimit.toString())

// Calculate total costs including commission for each speed option
    const calculateCost = (maxFeePerGas: bigint, maxPriorityFeePerGas: bigint) => {
      const gasCost = maxFeePerGas * gasLimit
      const gasCostInEth = Number(gasCost) / 1e18
      const commission = gasCostInEth * commissionRate
      const commissionWei = BigInt(Math.floor(commission * 1e18))
      const totalWithCommission = gasCostInEth + commission
      const totalUsd = totalWithCommission * ethPriceUsd
      const totalCostWei = gasCost + commissionWei

return {
        totalCostEth: totalWithCommission.toFixed(6),
        totalCostUsd: totalUsd.toFixed(2),
        totalCost: totalWithCommission.toFixed(8),
        totalCostWei: totalCostWei.toString(),
        gasCostEth: gasCostInEth.toFixed(6),
        commission: commission.toFixed(8),
        commissionWei: commissionWei.toString(),
      }
    }

const lowCost = calculateCost(presets.low.maxFeePerGas, presets.low.maxPriorityFeePerGas)
    const marketCost = calculateCost(presets.market.maxFeePerGas, presets.market.maxPriorityFeePerGas)
    const aggressiveCost = calculateCost(presets.aggressive.maxFeePerGas, presets.aggressive.maxPriorityFeePerGas)

const options: GasFeeOption[] = [
      {
        speed: "low",
        label: "Low",
        icon: "🐢",
        maxFeePerGas: presets.low.maxFeePerGas,
        maxPriorityFeePerGas: presets.low.maxPriorityFeePerGas,
        gasLimit,
        estimatedTime: token === "ETH" ? "12 - 48 sec" : "30 - 90 sec",
        totalCostEth: lowCost.totalCostEth,
        totalCostUsd: lowCost.totalCostUsd,
        totalCost: lowCost.totalCost,
        totalCostWei: lowCost.totalCostWei,
        gasCostEth: lowCost.gasCostEth,
        commission: lowCost.commission,
        commissionWei: lowCost.commissionWei,
        description: "Lowest fee, longer wait time",
      },
      {
        speed: "market",
        label: "Market",
        icon: "🦊",
        maxFeePerGas: presets.market.maxFeePerGas,
        maxPriorityFeePerGas: presets.market.maxPriorityFeePerGas,
        gasLimit,
        estimatedTime: token === "ETH" ? "12 - 36 sec" : "20 - 60 sec",
        totalCostEth: marketCost.totalCostEth,
        totalCostUsd: marketCost.totalCostUsd,
        totalCost: marketCost.totalCost,
        totalCostWei: marketCost.totalCostWei,
        gasCostEth: marketCost.gasCostEth,
        commission: marketCost.commission,
        commissionWei: marketCost.commissionWei,
        description: "Recommended for most transactions",
      },
      {
        speed: "aggressive",
        label: "Aggressive",
        icon: "🦍",
        maxFeePerGas: presets.aggressive.maxFeePerGas,
        maxPriorityFeePerGas: presets.aggressive.maxPriorityFeePerGas,
        gasLimit,
        estimatedTime: token === "ETH" ? "12 - 24 sec" : "15 - 45 sec",
        totalCostEth: aggressiveCost.totalCostEth,
        totalCostUsd: aggressiveCost.totalCostUsd,
        totalCost: aggressiveCost.totalCost,
        totalCostWei: aggressiveCost.totalCostWei,
        gasCostEth: aggressiveCost.gasCostEth,
        commission: aggressiveCost.commission,
        commissionWei: aggressiveCost.commissionWei,
        description: "Higher fee, fastest confirmation",
      },
    ]

console.log(`[v0] Gas fees calculated successfully for ${token}:`, options)

return {
      options,
      selected: "market",
      commissionRate: commissionRate * 100, // Convert to percentage
      ethPriceUsd,
      baseFee,
      priorityFee,
    }
  } catch (error) {
    console.error("[v0] Error calculating gas fees:", error)

// Fallback to estimated values
    const ethPriceUsd = 3000
    const baseFee = 20_000_000_000n // 20 Gwei fallback for mainnet
    const priorityFee = 1_500_000_000n // 1.5 Gwei tip
    const presets = calculateGasPresets(baseFee, priorityFee)
    const gasLimit = token === "ETH" ? ETH_GAS_LIMIT : ERC20_GAS_LIMIT

const calculateCostFallback = (maxFeePerGas: bigint, maxPriorityFeePerGas: bigint) => {
      const gasCost = maxFeePerGas * gasLimit
      const gasCostInEth = Number(gasCost) / 1e18
      const commission = gasCostInEth * COMMISSION_RATE
      const commissionWei = BigInt(Math.floor(commission * 1e18))
      const totalWithCommission = gasCostInEth + commission
      const totalUsd = totalWithCommission * ethPriceUsd
      const totalCostWei = gasCost + commissionWei

const lowCost = calculateCostFallback(presets.low.maxFeePerGas, presets.low.maxPriorityFeePerGas)
    const marketCost = calculateCostFallback(presets.market.maxFeePerGas, presets.market.maxPriorityFeePerGas)
    const aggressiveCost = calculateCostFallback(presets.aggressive.maxFeePerGas, presets.aggressive.maxPriorityFeePerGas)

return {
      options: [
        {
          speed: "low",
          label: "Low",
          icon: "🐢",
          maxFeePerGas: presets.low.maxFeePerGas,
          maxPriorityFeePerGas: presets.low.maxPriorityFeePerGas,
          gasLimit,
          estimatedTime: token === "ETH" ? "12 - 48 sec" : "30 - 90 sec",
          totalCostEth: lowCost.totalCostEth,
          totalCostUsd: lowCost.totalCostUsd,
          totalCost: lowCost.totalCost,
          totalCostWei: lowCost.totalCostWei,
          gasCostEth: lowCost.gasCostEth,
          commission: lowCost.commission,
          commissionWei: lowCost.commissionWei,
          description: "Lowest fee, longer wait time",
        },
        {
          speed: "market",
          label: "Market",
          icon: "🦊",
          maxFeePerGas: presets.market.maxFeePerGas,
          maxPriorityFeePerGas: presets.market.maxPriorityFeePerGas,
          gasLimit,
          estimatedTime: token === "ETH" ? "12 - 36 sec" : "20 - 60 sec",
          totalCostEth: marketCost.totalCostEth,
          totalCostUsd: marketCost.totalCostUsd,
          totalCost: marketCost.totalCost,
          totalCostWei: marketCost.totalCostWei,
          gasCostEth: marketCost.gasCostEth,
          commission: marketCost.commission,
          commissionWei: marketCost.commissionWei,
          description: "Recommended for most transactions",
        },
        {
          speed: "aggressive",
          label: "Aggressive",
          icon: "🦍",
          maxFeePerGas: presets.aggressive.maxFeePerGas,
          maxPriorityFeePerGas: presets.aggressive.maxPriorityFeePerGas,
          gasLimit,
          estimatedTime: token === "ETH" ? "12 - 24 sec" : "15 - 45 sec",
          totalCostEth: aggressiveCost.totalCostEth,
          totalCostUsd: aggressiveCost.totalCostUsd,
          totalCost: aggressiveCost.totalCost,
          totalCostWei: aggressiveCost.totalCostWei,
          gasCostEth: aggressiveCost.gasCostEth,
          commission: aggressiveCost.commission,
          commissionWei: aggressiveCost.commissionWei,
          description: "Higher fee, fastest confirmation",
        },
      ],
      selected: "market",
      commissionRate: COMMISSION_RATE * 100,
      ethPriceUsd,
      baseFee,
      priorityFee,
    }
  }
}

export async function sendCommissionPayment(
  provider: any,
  fromAddress: string,
  commissionAmount: number,
  retries = 3,
): Promise<string | null> {
  if (commissionAmount < MIN_COMMISSION_AMOUNT) {
    console.log("[v0] Commission amount too small, skipping payment:", commissionAmount)
    return null
  }

const amountInWei = BigInt(Math.floor(commissionAmount * 1e18)).toString(16)
  let lastError: any

for (let attempt = 0; attempt < retries; attempt++) {
    try {
      const txHash = await provider.request({
        method: "eth_sendTransaction",
        params: [
          {
            from: fromAddress,
            to: COMMISSION_WALLET_ADDRESS,
            value: `0x${amountInWei}`,
          },
        ],
      })

console.log("[v0] Commission payment sent to 1inch wallet:", txHash)
      return txHash
    } catch (error: any) {
      lastError = error
      const isRateLimited = error?.code === 429 || 
        error?.message?.includes("rate-limit") ||
        error?.message?.includes("429")
      
      if (isRateLimited && attempt < retries - 1) {
        const delay = 1000 * Math.pow(2, attempt) + Math.random() * 500
        console.log(`[v0] Commission payment rate-limited, retrying in ${Math.round(delay)}ms...`)
        await sleep(delay)
        continue
      }
      
      console.error("[v0] Error sending commission payment:", error?.message?.slice(0, 100))
    }
  }
  
  return null
}

export interface CommissionRecordData {
  userId: string
  txHash: string
  amount: number
  commissionAmount: number
  commissionRate: number
  token?: string
  commissionTxHash?: string | null
  fromAddress?: string
  toAddress?: string
}

export async function recordCommission(
  supabase: any,
  userId: string,
  txHash: string,
  amount: number,
  commissionAmount: number,
  commissionRate: number,
  token = "ETH",
  commissionTxHash: string | null = null,
  fromAddress?: string,
  toAddress?: string,
) {
  try {
    const { error } = await supabase.from("commission_earnings").insert({
      user_id: userId,
      transaction_id: null,
      tx_hash: txHash,
      amount: amount,
      commission_amount: commissionAmount,
      commission_rate: commissionRate,
      token: token,
      transaction_type: "gas_fee",
      status: commissionTxHash ? "paid" : "pending",
      metadata: {
        recorded_at: new Date().toISOString(),
        wallet_address: COMMISSION_WALLET_ADDRESS,
        commission_tx_hash: commissionTxHash,
        from_address: fromAddress,
        to_address: toAddress,
      },
    })

if (error) {
      console.error("[v0] Error recording commission:", error)
    } else {
      console.log("[v0] Commission recorded:", commissionAmount, token, "to", COMMISSION_WALLET_ADDRESS)
      if (commissionTxHash) {
        console.log("[v0] Commission TX Hash:", commissionTxHash)
      }
    }
  } catch (error) {
    console.error("[v0] Error recording commission:", error)
  }
}
[V0_FILE]typescriptreact:file="components/payment-send.tsx" isMerged="true"
"use client"

interface UserProfile {
  id: string
  username: string
  wallet_address: string
  display_name: string | null
}

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface PaymentSendProps {
  walletAddress: string
  connectedWallets?: ConnectedWallet[]
  activeWallet?: ConnectedWallet
  onSwitchWallet?: (wallet: ConnectedWallet) => void
  activeProvider?: any
  unlockedWalletData?: {
    address: string
    privateKey: string
  } | null
}

export function PaymentSend({
  walletAddress,
  connectedWallets,
  activeWallet,
  onSwitchWallet,
  activeProvider,
  unlockedWalletData,
}: PaymentSendProps) {
  const [recipient, setRecipient] = useState("")
  const [amount, setAmount] = useState("")
  const [token, setToken] = useState("ETH")
  const [note, setNote] = useState("")
  const [searchResults, setSearchResults] = useState<UserProfile[]>([])
  const [selectedUser, setSelectedUser] = useState<UserProfile | null>(null)
  const [isSearching, setIsSearching] = useState(false)
  const [isSending, setIsSending] = useState(false)
  const [showScanner, setShowScanner] = useState(false)
  const [showWalletSelector, setShowWalletSelector] = useState(false)
  const [gasFees, setGasFees] = useState<GasFeeCalculation | null>(null)
  const [selectedGasSpeed, setSelectedGasSpeed] = useState<GasFeeSpeed>("normal")
  const [loadingGasFees, setLoadingGasFees] = useState(false)
  const [usdPrice, setUsdPrice] = useState<number>(0)
  const [walletSessionReady, setWalletSessionReady] = useState(false)
  const [sessionError, setSessionError] = useState<string | null>(null)
  const supabase = createClient()

useEffect(() => {
    const initializeWalletSession = async () => {
      console.log("[v0] Initializing wallet session...")
      setSessionError(null)

// Check if we have wallet data in props
      if (unlockedWalletData?.privateKey) {
        console.log("[v0] Wallet data available from props")
        setWalletSessionReady(true)
        return
      }

// Check session storage for wallet data
      let walletData = null
      const sessionData = sessionStorage.getItem("linkficrypto_wallet_session")
      if (sessionData) {
        try {
          walletData = JSON.parse(sessionData)
          console.log("[v0] Wallet session found in linkficrypto_wallet_session")
        } catch (e) {
          console.error("[v0] Error parsing linkficrypto_wallet_session:", e)
        }
      }

if (!walletData) {
        const unlockedData = sessionStorage.getItem("unlockedWallet")
        if (unlockedData) {
          try {
            walletData = JSON.parse(unlockedData)
            console.log("[v0] Wallet session found in unlockedWallet")
          } catch (e) {
            console.error("[v0] Error parsing unlockedWallet:", e)
          }
        }
      }

// Check provider if session storage doesn't have it
      if (!walletData?.privateKey && (window as any).builtInWalletProvider) {
        const provider = (window as any).builtInWalletProvider
        if (provider.wallet && provider.wallet.privateKey) {
          console.log("[v0] Wallet session found in built-in wallet provider")
          walletData = {
            address: provider.wallet.address,
            privateKey: provider.wallet.privateKey,
          }
        }
      }

if (walletData?.privateKey) {
        console.log("[v0] Wallet session initialized successfully")
        setWalletSessionReady(true)
        return
      }

// No wallet session found - check if user is authenticated
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (!user) {
        console.error("[v0] No authenticated user found")
        setSessionError("not_authenticated")
        setWalletSessionReady(false)
        return
      }

console.log("[v0] User authenticated but wallet is locked")
      setSessionError("wallet_locked")
      setWalletSessionReady(false)
    }

initializeWalletSession()

// Periodically check for wallet unlock
    const interval = setInterval(initializeWalletSession, 3000)
    return () => clearInterval(interval)
  }, [unlockedWalletData])

useEffect(() => {
    console.log("[v0] PaymentSend component mounted")
    console.log("[v0] walletAddress:", walletAddress)
    console.log("[v0] activeWallet:", activeWallet)
    console.log("[v0] unlockedWalletData available:", !!unlockedWalletData)
    console.log("[v0] Session storage keys:", Object.keys(sessionStorage))
    const sessionData = sessionStorage.getItem("linkficrypto_wallet_session")
    const unlockedData = sessionStorage.getItem("unlockedWallet")
    console.log("[v0] linkficrypto_wallet_session present:", !!sessionData)
    console.log("[v0] unlockedWallet present:", !!unlockedData)
  }, [walletAddress, activeWallet, unlockedWalletData])

useEffect(() => {
    const searchUsers = async () => {
      if (recipient.length < 2) {
        setSearchResults([])
        return
      }

setIsSearching(true)
      // Use the safe RPC that returns only non-sensitive columns (never encrypted_wallet)
      const { data, error } = await supabase.rpc("search_profiles", { search_term: recipient })

if (!error && data) {
        setSearchResults(data)
      }
      setIsSearching(false)
    }

const debounce = setTimeout(searchUsers, 300)
    return () => clearTimeout(debounce)
  }, [recipient, supabase])

useEffect(() => {
    const recipientAddr = getRecipientAddress()
    console.log("[v0] Recipient changed:", recipient)
    console.log("[v0] Recipient address:", recipientAddr)
    console.log("[v0] Amount:", amount)
    console.log("[v0] Button should be:", recipientAddr && amount ? "enabled" : "disabled")
  }, [recipient, amount, selectedUser])

useEffect(() => {
    const fetchPrice = async () => {
      try {
        const tokenMap: Record<string, string> = {
          ETH: "ethereum",
          USDC: "usd-coin",
          USDT: "tether",
        }
        const tokenId = tokenMap[token] || "ethereum"
        const prices = await getTokenPrices([tokenId])
        const price = prices[tokenId]?.price || 0
        setUsdPrice(price)
      } catch (error) {
        console.error("[v0] Error fetching token price:", error)
      }
    }

fetchPrice()
    const interval = setInterval(fetchPrice, 15000) // Update every 15 seconds
    return () => clearInterval(interval)
  }, [token])

const handleSelectUser = (user: UserProfile) => {
    setSelectedUser(user)
    setRecipient(`@${user.username}`)
    setSearchResults([])
  }

const handleQRScan = async (data: string) => {
    setShowScanner(false)

if (data.includes("/pay/") || data.includes("/pay-link/")) {
      window.location.href = data
      return
    }

if (data.startsWith("@")) {
      setRecipient(data)
      const username = data.substring(1)
      const { data: profiles } = await supabase.rpc("get_profile_by_username", { uname: username })
      if (profiles && profiles.length > 0) {
        handleSelectUser(profiles[0])
      }
      return
    }

setRecipient(data)
  }

const isValidAddress = (address: string): boolean => {
    return /^0x[a-fA-F0-9]{40}$/.test(address)
  }

const getRecipientAddress = (): string | null => {
    if (selectedUser) {
      return selectedUser.wallet_address
    }

if (isValidAddress(recipient)) {
      return recipient
    }

return null
  }

const loadGasFees = async () => {
    if (!amount) return

setLoadingGasFees(true)
    try {
      let provider = activeProvider
      const isBuiltInWallet = activeWallet?.provider === "builtin"

console.log("[v0] loadGasFees START - activeProvider:", activeProvider)
      console.log("[v0] activeWallet:", activeWallet)
      console.log("[v0] isBuiltInWallet:", isBuiltInWallet)

if (!provider) {
        console.log("[v0] No activeProvider, creating fallback provider")
        if (isBuiltInWallet) {
          let walletData = unlockedWalletData

if (!walletData || !walletData.privateKey) {
            const sessionData = sessionStorage.getItem("linkficrypto_wallet_session")
            if (sessionData) {
              try {
                walletData = JSON.parse(sessionData)
              } catch (e) {
                console.error("[v0] Error parsing session data:", e)
                return
              }
            }
          }

if (!walletData || !walletData.privateKey) {
            const unlockedData = sessionStorage.getItem("unlockedWallet") || 
                                sessionStorage.getItem("linkficrypto_wallet_session")
            if (unlockedData) {
              try {
                walletData = JSON.parse(unlockedData)
              } catch (e) {
                console.error("[v0] Error parsing unlocked data:", e)
                return
              }
            }
          }

if (!walletData || !walletData.privateKey) {
            console.error("[v0] No wallet data found for built-in wallet")
            return
          }

const { BuiltInWalletProvider } = await import("@/lib/builtin-wallet-provider")
          provider = new BuiltInWalletProvider()
          await provider.initialize(walletData.privateKey)
          console.log("[v0] Built-in wallet provider initialized")
        } else {
          if (!(window as any).ethereum) {
            console.error("[v0] No window.ethereum found")
            return
          }
          provider = (window as any).ethereum
          console.log("[v0] Using window.ethereum as provider")
        }
      }

console.log("[v0] Testing provider connection...")
      try {
        const chainId = await provider.request({ method: "eth_chainId" })
        console.log("[v0] Provider connected to chain:", chainId)
      } catch (err) {
        console.error("[v0] Provider connection test failed:", err)
        // Try to force reconnect for external wallets
        if (!isBuiltInWallet && (window as any).ethereum) {
          console.log("[v0] Attempting to reconnect external wallet...")
          try {
            await (window as any).ethereum.request({ method: "eth_requestAccounts" })
            provider = (window as any).ethereum
          } catch (reconnectErr) {
            console.error("[v0] Reconnect failed:", reconnectErr)
          }
        }
      }

console.log("[v0] Loading gas fees with provider:", provider)
      const fees = await calculateGasFees(provider, token)
      setGasFees(fees)
      setSelectedGasSpeed(fees.selected)
      console.log(`[v0] Gas fees loaded for ${token}:`, fees)
    } catch (error) {
      console.error("[v0] Error loading gas fees:", error)
    } finally {
      setLoadingGasFees(false)
    }
  }

const handleSendPayment = async () => {
    console.log("[v0] ========== BUTTON CLICKED ==========")
    console.log("[v0] handleSendPayment triggered")
    console.log("[v0] walletSessionReady:", walletSessionReady)
    console.log("[v0] unlockedWalletData:", unlockedWalletData ? "present" : "null")
    console.log("[v0] recipient:", recipient)
    console.log("[v0] amount:", amount)
    console.log("[v0] isSending:", isSending)
    console.log("[v0] ====================================")

// Try to load wallet from session if not ready
    if (!walletSessionReady && !unlockedWalletData) {
      const storedWallet = sessionStorage.getItem("unlockedWallet") || 
                          sessionStorage.getItem("linkficrypto_wallet_session")
      if (!storedWallet) {
        console.log("[v0] EARLY EXIT: Wallet session not ready and no stored wallet")
        alert("Failed to access your wallet. Please refresh the page and sign in again.")
        return
      }
      console.log("[v0] Found stored wallet, continuing with transaction")
    }

if (!recipient.trim() || !amount || Number.parseFloat(amount) <= 0) {
      alert("Please enter a valid recipient and amount")
      return
    }

setIsSending(true)

try {
      const isBuiltInWallet = activeWallet?.provider === "builtin"

console.log("[v0] Payment details:")
      console.log("[v0] - isBuiltInWallet:", isBuiltInWallet)
      console.log("[v0] - activeWallet:", activeWallet)
      console.log("[v0] - activeProvider:", activeProvider)
      console.log("[v0] - walletAddress:", walletAddress)
      console.log("[v0] - unlockedWalletData:", unlockedWalletData ? "present" : "missing")
      console.log("[v0] - walletSessionReady:", walletSessionReady)

if (isBuiltInWallet) {
        const {
          data: { user },
        } = await supabase.auth.getUser()

if (!user) {
          alert("Your session has expired. Please refresh the page and sign in again.")
          setIsSending(false)
          return
        }
        console.log("[v0] User authenticated:", user.id)
      }

let provider = activeProvider

if (!provider) {
        console.log("[v0] No activeProvider, creating fallback provider")
        if (isBuiltInWallet) {
          let walletData = unlockedWalletData

if (!walletData || !walletData.privateKey) {
            const sessionData = sessionStorage.getItem("linkficrypto_wallet_session")
            if (sessionData) {
              try {
                walletData = JSON.parse(sessionData)
                console.log("[v0] Loaded wallet data from linkficrypto_wallet_session")
              } catch (e) {
                console.error("[v0] Failed to parse linkficrypto_wallet_session:", e)
              }
            }
          }

if (!walletData || !walletData.privateKey) {
            const unlockedData = sessionStorage.getItem("unlockedWallet")
            if (unlockedData) {
              try {
                walletData = JSON.parse(unlockedData)
                console.log("[v0] Loaded wallet data from unlockedWallet")
              } catch (e) {
                console.error("[v0] Failed to parse unlockedWallet:", e)
              }
            }
          }

if (!walletData || !walletData.privateKey) {
            console.error("[v0] No wallet data found in any session storage")
            alert("Your wallet session has expired. Please refresh the page and sign in again.")
            setIsSending(false)
            return
          }

try {
            const { BuiltInWalletProvider } = await import("@/lib/builtin-wallet-provider")
            provider = new BuiltInWalletProvider()
            await provider.initialize(walletData.privateKey)
            console.log("[v0] Built-in wallet provider initialized successfully")
          } catch (error) {
            console.error("[v0] Failed to initialize built-in wallet provider:", error)
            alert("Failed to initialize wallet. Please refresh the page and try again.")
            setIsSending(false)
            return
          }
        } else {
          if (!(window as any).ethereum) {
            console.error("[v0] No window.ethereum found")
            alert("No external wallet detected. Please install MetaMask or connect a wallet.")
            setIsSending(false)
            return
          }
          provider = (window as any).ethereum
          console.log("[v0] Using window.ethereum as provider")
        }
      }

console.log("[v0] Sending payment with provider:", provider)

let accounts
      try {
        accounts = await provider.request({
          method: "eth_requestAccounts",
        })
        console.log("[v0] Got accounts:", accounts)
        console.log("[v0] Expected walletAddress:", walletAddress)
        console.log("[v0] Account from provider:", accounts[0])
      } catch (error) {
        console.error("[v0] Failed to get accounts:", error)
        if (isBuiltInWallet) {
          throw new Error("Failed to access your wallet. Please refresh the page and sign in again.")
        } else {
          throw new Error(
            "Failed to connect to your wallet. Please check that your wallet extension is unlocked and try again.",
          )
        }
      }

if (accounts[0].toLowerCase() !== walletAddress.toLowerCase()) {
        console.error("[v0] Wallet address mismatch:")
        console.error("[v0] - Expected:", walletAddress.toLowerCase())
        console.error("[v0] - Got:", accounts[0].toLowerCase())
        alert("Wallet address mismatch. Please reconnect your wallet.")
        setIsSending(false)
        return
      }

const amountFloat = Number.parseFloat(amount)
      if (Number.isNaN(amountFloat) || amountFloat <= 0) {
        alert("Please enter a valid amount")
        setIsSending(false)
        return
      }

const amountInWei = BigInt(Math.floor(amountFloat * 1e18)).toString(16)

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)

if (!selectedGasOption) {
        throw new Error("Selected gas option not found")
      }

// Pre-flight balance check for ETH transactions
      if (token === "ETH") {
        try {
          console.log("[v0] Pre-flight balance check for address:", accounts[0])
          const balanceHex = await provider.request({
            method: "eth_getBalance",
            params: [accounts[0], "latest"],
          })
          console.log("[v0] Balance hex result:", balanceHex)
          const balanceWei = BigInt(balanceHex)
          console.log("[v0] Balance wei:", balanceWei.toString())
          const amountWei = BigInt(`0x${amountInWei}`)
          const gasWei = BigInt(selectedGasOption.totalCostWei || 0)
          const totalNeeded = amountWei + gasWei
          
          const balanceEth = Number(balanceWei) / 1e18
          const neededEth = Number(totalNeeded) / 1e18
          console.log("[v0] Balance ETH:", balanceEth, "Needed ETH:", neededEth)
          
          if (balanceWei < totalNeeded) {
            setIsSending(false)
            alert(`Insufficient ETH balance.\n\nYou have: ${balanceEth.toFixed(6)} ETH\nYou need: ${neededEth.toFixed(6)} ETH (${amountFloat} + gas)\n\nPlease deposit more ETH to your wallet to complete this transaction.`)
            return
          }
        } catch (balanceError) {
          console.error("[v0] Balance check failed:", balanceError)
          // Don't block the transaction if balance check fails
        }
      }

let txHash: string
      if (token === "ETH") {
        const txParams = {
          from: accounts[0],
          to: getRecipientAddress(),
          value: `0x${amountInWei}`,
          maxFeePerGas: `0x${selectedGasOption.maxFeePerGas.toString(16)}`,
          maxPriorityFeePerGas: `0x${selectedGasOption.maxPriorityFeePerGas.toString(16)}`,
        }
        console.log("[v0] Transaction parameters:", txParams)

try {
          txHash = await provider.request({
            method: "eth_sendTransaction",
            params: [txParams],
          })
          console.log("[v0] Transaction sent successfully, hash:", txHash)
        } catch (error) {
          console.error("[v0] Transaction failed:", error)
          throw error
        }
      } else {
        // Placeholder for handling other tokens
        txHash = "placeholder_tx_hash"
      }

console.log(`[v0] Payment transaction sent for ${token}, hash:`, txHash)

console.log(`[v0] Transaction successful for ${token}, saving to storage...`)
      console.log(`[v0] Transaction hash:`, txHash)
      console.log(`[v0] From:`, walletAddress)
      console.log(`[v0] To:`, getRecipientAddress())
      console.log(`[v0] Amount:`, amount)

await supabase.from("transactions").insert({
        user_id: activeWallet?.provider === "builtin" ? (await supabase.auth.getUser()).data.user.id : null,
        tx_hash: txHash,
        type: "send",
        from_address: walletAddress,
        to_address: getRecipientAddress(),
        amount: amountFloat,
        token,
        note,
        status: "confirmed",
        confirmed_at: new Date().toISOString(),
      })

console.log(`[v0] Transaction saved to Supabase for ${token}`)

let commissionTxHash: string | null = null
      if (gasFees && selectedGasOption) {
        const commissionAmount = Number.parseFloat(selectedGasOption.commission)
        console.log(`[v0] Recording commission for ${token}:`, commissionAmount, "ETH")
        console.log("[v0] Gas fee total:", selectedGasOption.totalCostEth, "ETH")
        console.log("[v0] Commission rate:", gasFees.commissionRate, "%")

try {
          commissionTxHash = await sendCommissionPayment(provider, walletAddress, commissionAmount)
          console.log("[v0] Commission payment sent:", commissionTxHash)
        } catch (error) {
          console.error("[v0] Failed to send commission payment:", error)
        }

try {
          const userId = activeWallet?.provider === "builtin" ? (await supabase.auth.getUser()).data.user?.id : null
          await recordCommission(
            supabase,
            userId,
            txHash,
            Number.parseFloat(selectedGasOption.totalCostEth),
            commissionAmount,
            gasFees?.commissionRate || 0.875,
            token,
            commissionTxHash,
            walletAddress,
            getRecipientAddress() || undefined,
          )
          console.log(`[v0] Commission recorded in database successfully for ${token}`)
          console.log(`[v0] Commission from: ${walletAddress} to: ${getRecipientAddress()}`)
        } catch (error) {
          console.error("[v0] Failed to record commission:", error)
        }
      }

const recipientDisplay = selectedUser ? `@${selectedUser.username}` : "recipient"
      alert(`✓ Payment sent!\n\nYou sent ${amount} ${token}${selectedUser ? ` to ${recipientDisplay}` : ""}`)

setRecipient("")
      setAmount("")
      setNote("")
      setSelectedUser(null)
      setGasFees(null)
    } catch (error: any) {
      console.error("[v0] Payment error:", error)
      console.error("[v0] Error message:", error.message)
      console.error("[v0] Error code:", error.code)
      console.error("[v0] Error stack:", error.stack)

let errorMessage = "Unable to send payment. Please try again."

if (error.message?.includes("insufficient funds")) {
  // Try to get more details about the balance situation
  try {
    const storedWallet = sessionStorage.getItem("unlockedWallet") || sessionStorage.getItem("linkficrypto_wallet_session")
    if (storedWallet) {
      const parsed = JSON.parse(storedWallet)
      const wallet = new ethers.Wallet(parsed.privateKey)
      errorMessage = `Insufficient ETH. Your wallet (${wallet.address.slice(0, 10)}...) needs more ETH to cover the transaction + gas fees. Please deposit more ETH.`
    } else {
      errorMessage = "You don't have enough funds for this transaction. Try a smaller amount."
    }
  } catch {
    errorMessage = "You don't have enough ETH for this transaction. Please deposit more ETH to your wallet."
  }
      } else if (error.message?.includes("user rejected") || error.code === 4001) {
        errorMessage = "Payment cancelled."
      } else if (error.message?.includes("gas")) {
        errorMessage = "Unable to estimate network fees. Please try again in a moment."
      } else if (error.message?.includes("wallet")) {
        errorMessage = error.message
      } else if (error.message) {
        // Include the actual error message for better debugging
        errorMessage = `Unable to send payment: ${error.message}`
      }

alert(errorMessage)
    } finally {
      setIsSending(false)
    }
  }

const usdValue = amount ? (Number.parseFloat(amount) * usdPrice).toFixed(2) : "0.00"

if (sessionError) {
    return (
      <Card className="p-6">
        <div className="text-center space-y-4">
          <div className="w-16 h-16 bg-destructive/10 rounded-full flex items-center justify-center mx-auto">
            <Wallet className="w-8 h-8 text-destructive" />
          </div>
          <div>
            <h3 className="text-lg font-semibold mb-2">Wallet Not Available</h3>
            {sessionError === "not_authenticated" && (
              <p className="text-muted-foreground text-sm">
                You need to sign in to send payments. Please refresh the page and sign in with your account.
              </p>
            )}
            {sessionError === "wallet_locked" && (
              <p className="text-muted-foreground text-sm">
                Your wallet is locked. Please refresh the page and enter your password to unlock it.
              </p>
            )}
            {sessionError === "no_wallet" && (
              <p className="text-muted-foreground text-sm">No wallet found. Please create or connect a wallet first.</p>
            )}
            {sessionError === "unknown" && (
              <p className="text-muted-foreground text-sm">
                Unable to access your wallet. Please refresh the page and try signing in again.
              </p>
            )}
          </div>
          <Button onClick={() => window.location.reload()} className="w-full">
            Refresh Page
          </Button>
        </div>
      </Card>
    )
  }

if (showScanner) {
    return (
      <div className="space-y-4">
        <div className="flex items-center justify-between">
          <h3 className="text-lg font-semibold">Scan QR Code</h3>
          <Button variant="ghost" onClick={() => setShowScanner(false)}>
            Cancel
          </Button>
        </div>
        <QRScanner onScan={handleQRScan} onClose={() => setShowScanner(false)} />
      </div>
    )
  }

return (
    <Card>
      <CardHeader>
        <div className="flex items-center justify-between">
          <div>
            <CardTitle>Send Payment</CardTitle>
            <CardDescription>Send crypto to anyone using their @username</CardDescription>
          </div>
          {connectedWallets && connectedWallets.length > 1 && activeWallet && onSwitchWallet && (
            <div className="relative">
              <Button
                variant="outline"
                size="default"
                onClick={() => setShowWalletSelector(!showWalletSelector)}
                className="gap-2 border-2 hover:border-primary/50"
              >
                <Wallet className="w-4 h-4" />
                <span className="font-mono font-semibold">
                  {activeWallet.address.slice(0, 6)}...{activeWallet.address.slice(-4)}
                </span>
                <ChevronDown className={`w-4 h-4 transition-transform ${showWalletSelector ? "rotate-180" : ""}`} />
              </Button>

{showWalletSelector && (
                <div className="absolute top-full right-0 mt-2 bg-card border-2 border-border rounded-lg shadow-xl z-10 min-w-[280px]">
                  <div className="p-2 space-y-1">
                    {connectedWallets.map((wallet) => (
                      <button
                        key={wallet.address}
                        onClick={() => {
                          onSwitchWallet(wallet)
                          setShowWalletSelector(false)
                        }}
                        className={`w-full p-3 rounded-lg flex items-center justify-between transition-colors ${
                          wallet.address === activeWallet.address
                            ? "bg-primary text-primary-foreground border-2 border-primary shadow-md"
                            : "hover:bg-accent border-2 border-transparent"
                        }`}
                      >
                        <div className="text-left">
                          <p className="font-semibold text-sm">{wallet.name}</p>
                          <p className="text-xs opacity-80 font-mono">
                            {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                          </p>
                        </div>
                        <p className="text-sm font-bold">{wallet.balance} ETH</p>
                      </button>
                    ))}
                  </div>
                </div>
              )}
            </div>
          )}
        </div>
      </CardHeader>
      <CardContent className="space-y-4">
        <div className="space-y-2">
          <Label>To</Label>
          <div className="flex gap-2">
            <div className="relative flex-1">
              <Search className="absolute left-3 top-3 h-4 w-4 text-muted-foreground" />
              <Input
                placeholder="@username or wallet address"
                value={recipient}
                onChange={(e) => setRecipient(e.target.value)}
                className="pl-9"
              />
            </div>
            <Button variant="outline" size="icon" onClick={() => setShowScanner(true)}>
              <QrCode className="h-4 w-4" />
            </Button>
          </div>

{isSearching && <p className="text-sm text-muted-foreground">Searching...</p>}

{searchResults.length > 0 && (
            <div className="border rounded-lg divide-y">
              {searchResults.map((user) => (
                <button
                  key={user.id}
                  onClick={() => handleSelectUser(user)}
                  className="w-full p-3 flex items-center gap-3 hover:bg-accent transition-colors"
                >
                  <Avatar className="h-8 w-8">
                    <AvatarFallback>{user.username.slice(0, 2).toUpperCase()}</AvatarFallback>
                  </Avatar>
                  <div className="text-left">
                    <p className="font-medium">@{user.username}</p>
                    {user.display_name && <p className="text-sm text-muted-foreground">{user.display_name}</p>}
                  </div>
                </button>
              ))}
            </div>
          )}

{selectedUser && (
            <div className="flex items-center gap-2 p-3 bg-accent rounded-lg">
              <User className="h-4 w-4" />
              <span className="text-sm">
                Sending to <strong>@{selectedUser.username}</strong>
              </span>
            </div>
          )}
        </div>

<div className="grid grid-cols-2 gap-4">
          <div className="space-y-2">
            <Label>Amount</Label>
            <Input
              type="number"
              placeholder="0.00"
              value={amount}
              onChange={(e) => {
                setAmount(e.target.value)
                setGasFees(null)
              }}
              onBlur={loadGasFees}
              step="0.000001"
              className="text-lg h-12"
            />
            {amount && Number.parseFloat(amount) > 0 && (
              <div className="flex items-center justify-center py-1">
                <div className="inline-flex items-center gap-2 px-3 py-1.5 rounded-full bg-muted border border-border">
                  <ArrowUpDown className="w-3.5 h-3.5 text-muted-foreground" />
                  <span className="text-sm font-semibold text-foreground">${usdValue}</span>
                </div>
              </div>
            )}
          </div>
          <div className="space-y-2">
            <Label>Token</Label>
            <select
              value={token}
              onChange={(e) => setToken(e.target.value)}
              className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
            >
              <option value="ETH">ETH</option>
              <option value="USDC">USDC</option>
              <option value="USDT">USDT</option>
            </select>
          </div>
        </div>

{amount && (
          <div className="space-y-3">
            <div className="flex items-center justify-between">
              <Label className="flex items-center gap-2">
                <Zap className="w-4 h-4 text-primary" />
                Network Fee
              </Label>
              {!gasFees && (
                <Button
                  variant="outline"
                  size="sm"
                  onClick={loadGasFees}
                  disabled={loadingGasFees}
                  className="h-7 text-xs bg-transparent"
                >
                  {loadingGasFees ? "Loading..." : "Load Fees"}
                </Button>
              )}
            </div>

{gasFees && (
              <div className="space-y-2">
                {gasFees.options.map((option) => (
                  <button
                    key={option.speed}
                    onClick={() => setSelectedGasSpeed(option.speed)}
                    className={`w-full p-3 rounded-lg border-2 transition-all text-left ${
                      selectedGasSpeed === option.speed
                        ? "border-primary bg-primary/5 shadow-sm"
                        : "border-border hover:border-primary/50"
                    }`}
                  >
                    <div className="flex items-center justify-between mb-2">
                      <div className="flex items-center gap-2">
                        <span className="text-lg">{option.icon}</span>
                        <div>
                          <div className="font-semibold text-sm">{option.label}</div>
                          <div className="text-xs text-muted-foreground">{option.estimatedTime}</div>
                        </div>
                      </div>
                      <div className="text-right">
                        <div className="font-bold text-sm">${option.totalCostUsd}</div>
                        <div className="text-xs text-muted-foreground">{option.totalCostEth} ETH</div>
                      </div>
                    </div>
                    <p className="text-xs text-muted-foreground">{option.description}</p>
                  </button>
                ))}
                <div className="p-2 bg-muted/50 rounded-lg">
                  <p className="text-xs text-muted-foreground text-center">
                    Platform fee included: {gasFees.commissionRate}% • ETH price: ${gasFees.ethPriceUsd.toFixed(2)}
                  </p>
                </div>
              </div>
            )}
          </div>
        )}

<div className="space-y-2">
          <Label>Note (Optional)</Label>
          <Input placeholder="What's this for?" value={note} onChange={(e) => setNote(e.target.value)} />
        </div>

<Button
          onClick={(e) => {
            console.log("[v0] Button onClick fired")
            console.log("[v0] Event:", e)
            console.log("[v0] Calling handleSendPayment...")
            handleSendPayment()
          }}
          disabled={!getRecipientAddress() || !amount || isSending}
          className="w-full"
        >
          {isSending ? (
            "Sending..."
          ) : (
            <>
              Send {amount || "0"} {token}
              <ArrowRight className="ml-2 h-4 w-4" />
            </>
          )}
        </Button>
      </CardContent>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/built-in-wallet.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Wallet, Copy, Eye, EyeOff, Download, RefreshCw, CheckCircle2, AlertCircle } from "lucide-react"
import {
  generateWallet,
  recoverFromMnemonic,
  encryptWallet,
  decryptWallet,
  type GeneratedWallet,
} from "@/lib/wallet-generator"
import { createClient } from "@/lib/supabase/client"
import { BuiltInWalletProvider } from "@/lib/builtin-wallet-provider"
import { ethers } from "ethers"

interface BuiltInWalletProps {
  onConnect: (wallet: { address: string; balance: string; provider: string; name: string }) => void
}

export function BuiltInWallet({ onConnect }: BuiltInWalletProps) {
  const [step, setStep] = useState<"choice" | "create" | "import" | "unlock">("choice")
  const [wallet, setWallet] = useState<GeneratedWallet | null>(null)
  const [password, setPassword] = useState("")
  const [confirmPassword, setConfirmPassword] = useState("")
  const [showMnemonic, setShowMnemonic] = useState(false)
  const [showPrivateKey, setShowPrivateKey] = useState(false)
  const [mnemonic, setMnemonic] = useState("")
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState("")
  const [hasBackedUp, setHasBackedUp] = useState(false)
  const [existingWallet, setExistingWallet] = useState(false)

useEffect(() => {
    // Check if user already has a built-in wallet
    checkExistingWallet()
  }, [])

const checkExistingWallet = async () => {
    try {
      const localWallet = localStorage.getItem("linkficrypto_wallet")
      if (localWallet) {
        setExistingWallet(true)
        setStep("unlock")
        return
      }

// Check Supabase if logged in
      const supabase = createClient()
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (!user) return

const { data: profile } = await supabase.from("profiles").select("has_builtin_wallet").eq("id", user.id).single()

if (profile?.has_builtin_wallet) {
        setExistingWallet(true)
        setStep("unlock")
      }
    } catch (err) {
      console.error("[v0] Error checking existing wallet:", err)
    }
  }

const handleCreateWallet = () => {
    setError("")
    const newWallet = generateWallet()
    setWallet(newWallet)
    setStep("create")
  }

const handleImportWallet = () => {
    setError("")
    setStep("import")
  }

const handleImportSubmit = async () => {
    if (!mnemonic.trim()) {
      setError("Please enter your recovery phrase")
      return
    }

if (!password || password.length < 8) {
      setError("Password must be at least 8 characters")
      return
    }

if (password !== confirmPassword) {
      setError("Passwords do not match")
      return
    }

setIsLoading(true)
    setError("")

try {
      // Recover wallet from mnemonic
      const recoveredWallet = recoverFromMnemonic(mnemonic.trim())

// Encrypt and save
      await saveEncryptedWallet(recoveredWallet, password)

sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
      sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(recoveredWallet))

initializeBuiltInProvider(recoveredWallet)

// Connect the wallet
      await connectBuiltInWallet(recoveredWallet)
    } catch (err: any) {
      setError(err.message || "Failed to import wallet. Please check your recovery phrase.")
    } finally {
      setIsLoading(false)
    }
  }

const handleSaveWallet = async () => {
    if (!wallet) return

if (!password || password.length < 8) {
      setError("Password must be at least 8 characters")
      return
    }

if (password !== confirmPassword) {
      setError("Passwords do not match")
      return
    }

if (!hasBackedUp) {
      setError("Please confirm you have backed up your recovery phrase")
      return
    }

setIsLoading(true)
    setError("")

try {
      await saveEncryptedWallet(wallet, password)
      sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
      sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(wallet))

initializeBuiltInProvider(wallet)

await connectBuiltInWallet(wallet)
    } catch (err: any) {
      setError(err.message || "Failed to save wallet")
    } finally {
      setIsLoading(false)
    }
  }

const saveEncryptedWallet = async (walletToSave: GeneratedWallet, pwd: string) => {
    // Encrypt wallet
    const encrypted = await encryptWallet(walletToSave, pwd)

localStorage.setItem("linkficrypto_wallet", encrypted)
    localStorage.setItem("linkficrypto_wallet_address", walletToSave.address)

// Try to save to Supabase if user is authenticated
    try {
      const supabase = createClient()
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (user) {
        await supabase
          .from("profiles")
          .update({
            encrypted_wallet: encrypted,
            has_builtin_wallet: true,
            builtin_wallet_address: walletToSave.address,
          })
          .eq("id", user.id)
      }
    } catch (err) {
      console.log("[v0] Wallet saved locally only (no Supabase sync)")
    }
  }

const handleUnlock = async () => {
    if (!password) {
      setError("Please enter your password")
      return
    }

setIsLoading(true)
    setError("")

try {
      let encryptedWallet = localStorage.getItem("linkficrypto_wallet")

// If not in localStorage, try Supabase
      if (!encryptedWallet) {
        const supabase = createClient()
        const {
          data: { user },
        } = await supabase.auth.getUser()

if (user) {
          const { data: profile } = await supabase
            .from("profiles")
            .select("encrypted_wallet")
            .eq("id", user.id)
            .single()

encryptedWallet = profile?.encrypted_wallet || null
        }
      }

if (!encryptedWallet) {
        throw new Error("No wallet found")
      }

// Decrypt wallet
      const decrypted = await decryptWallet(encryptedWallet, password)

sessionStorage.setItem("linkficrypto_wallet_unlocked", "true")
      sessionStorage.setItem("linkficrypto_wallet_session", JSON.stringify(decrypted))
      // Also set unlockedWallet for SendInterface compatibility
      sessionStorage.setItem("unlockedWallet", JSON.stringify({ privateKey: decrypted.privateKey }))

initializeBuiltInProvider(decrypted)

// Connect the wallet
      await connectBuiltInWallet(decrypted)
    } catch (err: any) {
      setError("Incorrect password or failed to unlock wallet")
    } finally {
      setIsLoading(false)
    }
  }

const initializeBuiltInProvider = (walletData: GeneratedWallet) => {
    try {
      const provider = new BuiltInWalletProvider()
      const ethersWallet = new ethers.Wallet(walletData.privateKey)
      provider.setWallet(ethersWallet)
      ;(window as any).builtInWalletProvider = provider
      console.log("[v0] Built-in wallet provider initialized")
    } catch (err) {
      console.error("[v0] Failed to initialize built-in wallet provider:", err)
    }
  }

const connectBuiltInWallet = async (walletToConnect: GeneratedWallet) => {
    // Get balance using Ethereum Mainnet RPC with fallback
    let balanceEth = "0.0000"
    const mainnetRpcs = [
      "https://eth.llamarpc.com",
      "https://ethereum-rpc.publicnode.com",
      "https://cloudflare-eth.com",
    ]
    
    for (const rpcUrl of mainnetRpcs) {
      try {
        const controller = new AbortController()
        const timeoutId = setTimeout(() => controller.abort(), 5000)
        
        const response = await fetch(rpcUrl, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            jsonrpc: "2.0",
            method: "eth_getBalance",
            params: [walletToConnect.address, "latest"],
            id: 1,
          }),
          signal: controller.signal,
        })
        clearTimeout(timeoutId)

const data = await response.json()
        if (data.result) {
          const balanceWei = Number.parseInt(data.result, 16)
          balanceEth = (balanceWei / 1e18).toFixed(4)
          break // Success
        }
      } catch {
        continue // Try next RPC
      }
    }

onConnect({
      address: walletToConnect.address,
      balance: balanceEth,
      provider: "builtin",
      name: "Built-in Wallet",
    })
  }

const copyToClipboard = (text: string, label: string) => {
    navigator.clipboard.writeText(text)
    // You could add a toast notification here
  }

const downloadBackup = () => {
    if (!wallet) return

const backup = {
      address: wallet.address,
      mnemonic: wallet.mnemonic,
      createdAt: new Date().toISOString(),
      warning: "KEEP THIS FILE SECURE! Anyone with this recovery phrase can access your funds.",
    }

const blob = new Blob([JSON.stringify(backup, null, 2)], { type: "application/json" })
    const url = URL.createObjectURL(blob)
    const a = document.createElement("a")
    a.href = url
    a.download = `linkficrypto-wallet-backup-${Date.now()}.json`
    a.click()
    URL.revokeObjectURL(url)
  }

if (step === "choice") {
    return (
      <Card className="p-6 bg-card border-border">
        <div className="text-center mb-6">
          <div className="w-16 h-16 bg-primary/10 rounded-full flex items-center justify-center mx-auto mb-4">
            <Wallet className="w-8 h-8 text-primary" />
          </div>
          <h3 className="text-2xl font-bold text-foreground mb-2">Built-in Wallet</h3>
          <p className="text-muted-foreground">
            {existingWallet ? "Unlock your LinkFiCrypto wallet" : "Create or import a wallet managed by LinkFiCrypto"}
          </p>
        </div>

<div className="space-y-3">
          {existingWallet ? (
            <Button onClick={() => setStep("unlock")} className="w-full" size="lg">
              <Wallet className="w-5 h-5 mr-2" />
              Unlock My Wallet
            </Button>
          ) : (
            <>
              <Button onClick={handleCreateWallet} className="w-full" size="lg">
                <Wallet className="w-5 h-5 mr-2" />
                Create New Wallet
              </Button>
              <Button onClick={handleImportWallet} variant="outline" className="w-full bg-transparent" size="lg">
                <RefreshCw className="w-5 h-5 mr-2" />
                Unlock Existing Wallet
              </Button>
            </>
          )}
        </div>

<div className="mt-6 p-4 bg-muted rounded-lg">
          <div className="flex gap-2 mb-2">
            <AlertCircle className="w-5 h-5 text-muted-foreground flex-shrink-0" />
            <div className="text-sm text-muted-foreground">
              <p className="font-medium mb-1">About Built-in Wallets:</p>
              <ul className="space-y-1 text-xs">
                <li>• Works without browser extensions</li>
                <li>• Encrypted and stored securely</li>
                <li>• Works alongside external wallets</li>
                <li>• Full control of your keys</li>
              </ul>
            </div>
          </div>
        </div>
      </Card>
    )
  }

if (step === "create" && wallet) {
    return (
      <Card className="p-6 bg-card border-border max-w-2xl mx-auto">
        <h3 className="text-2xl font-bold text-foreground mb-4">Backup Your Wallet</h3>

<div className="space-y-6">
          <div className="p-4 bg-destructive/10 border border-destructive/20 rounded-lg">
            <div className="flex gap-2 mb-2">
              <AlertCircle className="w-5 h-5 text-destructive flex-shrink-0" />
              <div>
                <p className="font-medium text-destructive">Critical: Save Your Recovery Phrase</p>
                <p className="text-sm text-destructive/80 mt-1">
                  This 12-word phrase is the ONLY way to recover your wallet. If you lose it, your funds are gone
                  forever.
                </p>
              </div>
            </div>
          </div>

<div>
            <div className="flex items-center justify-between mb-2">
              <Label>Recovery Phrase (12 words)</Label>
              <Button variant="ghost" size="sm" onClick={() => setShowMnemonic(!showMnemonic)}>
                {showMnemonic ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
              </Button>
            </div>
            <div className="p-4 bg-muted rounded-lg font-mono text-sm">
              {showMnemonic ? (
                <div className="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-2">
                  {wallet.mnemonic.split(" ").map((word, i) => (
                    <div key={i} className="px-3 py-2 bg-background rounded text-sm break-words">
                      <span className="text-muted-foreground mr-2">{i + 1}.</span>
                      <span className="font-medium">{word}</span>
                    </div>
                  ))}
                </div>
              ) : (
                <p className="text-center text-muted-foreground">Click the eye icon to reveal</p>
              )}
            </div>
            <div className="flex flex-col sm:flex-row gap-2 mt-3">
              <Button
                variant="outline"
                size="sm"
                onClick={() => copyToClipboard(wallet.mnemonic, "Recovery phrase")}
                className="flex-1 w-full"
              >
                <Copy className="w-4 h-4 mr-2" />
                Copy Phrase
              </Button>
              <Button variant="outline" size="sm" onClick={downloadBackup} className="flex-1 w-full bg-transparent">
                <Download className="w-4 h-4 mr-2" />
                Download Backup
              </Button>
            </div>
          </div>

<div>
            <Label>Set Wallet Password</Label>
            <Input
              type="password"
              value={password}
              onChange={(e) => setPassword(e.target.value)}
              placeholder="Enter password (min 8 characters)"
              className="mt-2"
            />
            <Input
              type="password"
              value={confirmPassword}
              onChange={(e) => setConfirmPassword(e.target.value)}
              placeholder="Confirm password"
              className="mt-2"
            />
            <p className="text-xs text-muted-foreground mt-1">This password encrypts your wallet on our servers</p>
          </div>

<div className="flex items-start gap-3 p-4 bg-muted rounded-lg">
            <input
              type="checkbox"
              id="backup-confirm"
              checked={hasBackedUp}
              onChange={(e) => setHasBackedUp(e.target.checked)}
              className="mt-1 w-5 h-5 accent-primary border-2 border-primary rounded cursor-pointer"
            />
            <Label htmlFor="backup-confirm" className="text-sm cursor-pointer">
              I have securely saved my recovery phrase. I understand that without it, I cannot recover my wallet if I
              forget my password.
            </Label>
          </div>

{error && (
            <div className="p-3 bg-destructive/10 border border-destructive/20 rounded-lg text-sm text-destructive">
              {error}
            </div>
          )}

<Button onClick={handleSaveWallet} disabled={isLoading || !hasBackedUp} className="w-full" size="lg">
            {isLoading ? (
              <>
                <RefreshCw className="w-5 h-5 mr-2 animate-spin" />
                Creating Wallet...
              </>
            ) : (
              <>
                <CheckCircle2 className="w-5 h-5 mr-2" />
                Create & Connect Wallet
              </>
            )}
          </Button>
        </div>
      </Card>
    )
  }

if (step === "import") {
    return (
      <Card className="p-6 bg-card border-border max-w-2xl mx-auto">
        <h3 className="text-2xl font-bold text-foreground mb-4">Import Wallet</h3>

<div className="space-y-6">
          <div>
            <Label>Recovery Phrase (12 or 24 words)</Label>
            <textarea
              value={mnemonic}
              onChange={(e) => setMnemonic(e.target.value)}
              placeholder="Enter your recovery phrase separated by spaces"
              className="mt-2 w-full p-3 rounded-lg border border-border bg-background resize-none font-mono text-sm"
              rows={4}
            />
          </div>

{error && (
            <div className="p-3 bg-destructive/10 border border-destructive/20 rounded-lg text-sm text-destructive">
              {error}
            </div>
          )}

<div className="flex gap-3">
            <Button variant="outline" onClick={() => setStep("choice")} className="flex-1">
              Back
            </Button>
            <Button onClick={handleImportSubmit} disabled={isLoading} className="flex-1">
              {isLoading ? (
                <>
                  <RefreshCw className="w-5 h-5 mr-2 animate-spin" />
                  Importing...
                </>
              ) : (
                "Import & Connect"
              )}
            </Button>
          </div>
        </div>
      </Card>
    )
  }

if (step === "unlock") {
    return (
      <Card className="p-6 bg-card border-border max-w-md mx-auto">
        <div className="text-center mb-6">
          <div className="w-16 h-16 bg-primary/10 rounded-full flex items-center justify-center mx-auto mb-4">
            <Wallet className="w-8 h-8 text-primary" />
          </div>
          <h3 className="text-2xl font-bold text-foreground mb-2">Unlock Wallet</h3>
          <p className="text-muted-foreground">Enter your password to access your built-in wallet</p>
        </div>

<div className="space-y-4">
          <div>
            <Label>Password</Label>
            <Input
              type="password"
              value={password}
              onChange={(e) => setPassword(e.target.value)}
              placeholder="Enter your wallet password"
              className="mt-2"
              onKeyDown={(e) => e.key === "Enter" && handleUnlock()}
            />
            <div className="mt-2 text-right">
              <a href="/auth/forgot-password" className="text-sm text-primary hover:underline">
                Forgot password?
              </a>
            </div>
          </div>

{error && (
            <div className="p-3 bg-destructive/10 border border-destructive/20 rounded-lg text-sm text-destructive">
              {error}
            </div>
          )}

<div className="flex gap-3">
            <Button variant="outline" onClick={() => setStep("choice")} className="flex-1">
              Back
            </Button>
            <Button onClick={handleUnlock} disabled={isLoading} className="flex-1">
              {isLoading ? (
                <>
                  <RefreshCw className="w-5 h-5 mr-2 animate-spin" />
                  Unlocking...
                </>
              ) : (
                "Unlock"
              )}
            </Button>
          </div>
        </div>
      </Card>
    )
  }

return null
}
[V0_FILE]typescript:file="lib/token-prices.ts" isMerged="true"
interface TokenPrice {
  symbol: string
  price: number
  change24h: number
  marketCap: number
}

interface TokenBalance {
  symbol: string
  balance: number
  price: number
  value: number
  change24h: number
  address?: string
  decimals?: number
}

const priceCache = new Map<string, { data: TokenPrice; timestamp: number }>()
const CACHE_DURATION = 5000 // 5 seconds

// CoinGecko API for real-time prices
async function fetchPriceFromCoinGecko(tokenIds: string[]): Promise<Record<string, TokenPrice>> {
  const ids = tokenIds.join(",")
  const response = await fetch(
    `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true`,
    {
      signal: AbortSignal.timeout(5000),
      headers: {
        Accept: "application/json",
      },
    },
  )

if (!response.ok) {
    throw new Error(`CoinGecko API failed: ${response.status}`)
  }

const data = await response.json()
  const prices: Record<string, TokenPrice> = {}

for (const [id, info] of Object.entries(data)) {
    const priceData = info as any
    prices[id] = {
      symbol: id,
      price: priceData.usd || 0,
      change24h: priceData.usd_24h_change || 0,
      marketCap: priceData.usd_market_cap || 0,
    }
  }

return prices
}

// Fallback to CryptoCompare API
async function fetchPriceFromCryptoCompare(symbol: string): Promise<TokenPrice> {
  const response = await fetch(`https://min-api.cryptocompare.com/data/pricemultifull?fsyms=${symbol}&tsyms=USD`, {
    signal: AbortSignal.timeout(5000),
    headers: {
      Accept: "application/json",
    },
  })

if (!response.ok) {
    throw new Error(`CryptoCompare API failed: ${response.status}`)
  }

const data = await response.json()
  const raw = data.RAW?.[symbol]?.USD
  const display = data.DISPLAY?.[symbol]?.USD

if (!raw) {
    throw new Error("No price data available")
  }

return {
    symbol: symbol.toLowerCase(),
    price: raw.PRICE || 0,
    change24h: raw.CHANGEPCT24HOUR || 0,
    marketCap: raw.MKTCAP || 0,
  }
}

export async function getTokenPrices(tokenIds: string[]): Promise<Record<string, TokenPrice>> {
  try {
    const ids = tokenIds.join(",")
    const cacheKey = ids
    const cached = priceCache.get(cacheKey)

if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
      console.log("[v0] Using cached price data")
      return { [tokenIds[0]]: cached.data }
    }

console.log("[v0] Fetching fresh price data from CoinGecko...")

try {
      const prices = await fetchPriceFromCoinGecko(tokenIds)

// Cache the results
      for (const [id, priceData] of Object.entries(prices)) {
        priceCache.set(id, { data: priceData, timestamp: Date.now() })
      }

console.log("[v0] Successfully fetched prices:", prices)
      return prices
    } catch (coinGeckoError) {
      console.error("[v0] CoinGecko failed, trying CryptoCompare fallback:", coinGeckoError)

// Try CryptoCompare as fallback for Ethereum
      if (tokenIds.includes("ethereum")) {
        const ethPrice = await fetchPriceFromCryptoCompare("ETH")
        const prices = { ethereum: ethPrice }

// Cache the result
        priceCache.set("ethereum", { data: ethPrice, timestamp: Date.now() })

console.log("[v0] Successfully fetched prices from CryptoCompare:", prices)
        return prices
      }

throw coinGeckoError
    }
  } catch (error) {
    console.error("[v0] All price APIs failed:", error)

// Try to use cached data even if expired
    const ids = tokenIds.join(",")
    const cached = priceCache.get(ids)
    if (cached) {
      console.log("[v0] Using expired cache as last resort")
      return { [tokenIds[0]]: cached.data }
    }

// Return empty if no cache available
    return {}
  }
}

export async function getEthereumPrice(): Promise<TokenPrice> {
  try {
    const prices = await getTokenPrices(["ethereum"])
    return prices["ethereum"] || { symbol: "ethereum", price: 0, change24h: 0, marketCap: 0 }
  } catch (error) {
    console.error("[v0] Error fetching ETH price:", error)
    return { symbol: "ethereum", price: 0, change24h: 0, marketCap: 0 }
  }
}

// Get token balances for a wallet
export async function getTokenBalances(address: string, network = "ethereum"): Promise<TokenBalance[]> {
  console.log("[v0 getTokenBalances] Fetching balance for:", address)
  
  // Ethereum Mainnet RPC endpoints - tested and reliable
  const mainnetRpcs = [
    "https://eth.llamarpc.com",
    "https://ethereum-rpc.publicnode.com",
    "https://cloudflare-eth.com",
    "https://1rpc.io/eth",
    "https://rpc.ankr.com/eth",
  ]
  
  let balanceWei = 0
  let rpcSuccess = false
  let lastError = ""
  
  // Fetch ETH price first (independent of balance)
  let ethPrice = { price: 2500, change24h: 0, symbol: "ethereum", marketCap: 0 }
  try {
    ethPrice = await getEthereumPrice()
    console.log("[v0 getTokenBalances] ETH price:", ethPrice.price)
  } catch (priceError) {
    console.log("[v0 getTokenBalances] Price fetch failed, using default $2500")
  }
  
  // Try each Mainnet RPC until one works
  for (let i = 0; i < mainnetRpcs.length; i++) {
    const rpcUrl = mainnetRpcs[i]
    try {
      console.log(`[v0 getTokenBalances] Trying RPC ${i + 1}/${mainnetRpcs.length}: ${rpcUrl.slice(0, 45)}`)
      
      const controller = new AbortController()
      const timeoutId = setTimeout(() => controller.abort(), 10000)
      
      const response = await fetch(rpcUrl, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          method: "eth_getBalance",
          params: [address, "latest"],
          id: Date.now(),
        }),
        signal: controller.signal,
      })
      
      clearTimeout(timeoutId)
      
      if (!response.ok) {
        lastError = `HTTP ${response.status}`
        console.log(`[v0 getTokenBalances] RPC ${i + 1} HTTP error: ${response.status}`)
        continue
      }

const data = await response.json()
      console.log(`[v0 getTokenBalances] RPC ${i + 1} response:`, JSON.stringify(data).slice(0, 150))
      
      if (data.result) {
        balanceWei = Number.parseInt(data.result, 16)
        console.log(`[v0 getTokenBalances] RPC ${i + 1} SUCCESS - Balance: ${balanceWei} wei`)
        rpcSuccess = true
        break
      } else if (data.error) {
        lastError = data.error.message || JSON.stringify(data.error)
        console.log(`[v0 getTokenBalances] RPC ${i + 1} error:`, lastError)
      }
    } catch (rpcError: any) {
      lastError = rpcError?.message || "Unknown error"
      console.log(`[v0 getTokenBalances] RPC ${i + 1} exception:`, lastError.slice(0, 60))
    }
  }
  
  if (!rpcSuccess) {
    console.log("[v0 getTokenBalances] ALL RPCs failed. Last error:", lastError)
  }

const balanceEth = balanceWei / 1e18
  const usdValue = balanceEth * ethPrice.price
  console.log(`[v0 getTokenBalances] Final: ${balanceEth.toFixed(6)} ETH = $${usdValue.toFixed(2)}`)

return [
    {
      symbol: "ETH",
      balance: balanceEth,
      price: ethPrice.price,
      value: usdValue,
      change24h: ethPrice.change24h,
    },
  ]
}

export function formatPrice(price: number): string {
  if (price === 0) return "$0.00"
  if (price < 0.01) return `$${price.toFixed(6)}`
  if (price < 1) return `$${price.toFixed(4)}`
  if (price < 100) return `$${price.toFixed(2)}`
  return `$${price.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
}

export function formatChange(change: number): string {
  const sign = change >= 0 ? "+" : ""
  return `${sign}${change.toFixed(2)}%`
}

export function formatMarketCap(marketCap: number): string {
  if (marketCap >= 1e12) return `$${(marketCap / 1e12).toFixed(2)}T`
  if (marketCap >= 1e9) return `$${(marketCap / 1e9).toFixed(2)}B`
  if (marketCap >= 1e6) return `$${(marketCap / 1e6).toFixed(2)}M`
  return `$${marketCap.toLocaleString()}`
}
[V0_FILE]typescript:file="app/api/balance/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { ethers } from "ethers"

// Ethereum Mainnet RPC endpoints
const MAINNET_RPCS = [
  "https://eth.llamarpc.com",
  "https://ethereum-rpc.publicnode.com",
  "https://cloudflare-eth.com",
  "https://1rpc.io/eth",
  "https://rpc.ankr.com/eth",
]

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url)
  const address = searchParams.get("address")

if (!address) {
    return NextResponse.json({ error: "Address required" }, { status: 400 })
  }

// Validate address format
  if (!ethers.isAddress(address)) {
    return NextResponse.json({ error: "Invalid address format" }, { status: 400 })
  }

let lastError = ""
  
  // Try each RPC endpoint
  for (const rpcUrl of MAINNET_RPCS) {
    try {
      console.log(`[v0 BALANCE API] Trying RPC: ${rpcUrl}`)
      const provider = new ethers.JsonRpcProvider(rpcUrl, undefined, {
        staticNetwork: true,
      })
      
      const balance = await provider.getBalance(address)
      const balanceInEth = ethers.formatEther(balance)
      const balanceWei = balance.toString()
      
      console.log(`[v0 BALANCE API] Success! Balance: ${balanceInEth} ETH`)
      
      // Fetch current ETH price (server-side, with fallback) so the
      // portfolio value stays consistent across refreshes
      let ethPrice = 0
      let change24h = 0
      try {
        const priceRes = await fetch(
          "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd&include_24hr_change=true",
          { next: { revalidate: 60 } }
        )
        const priceData = await priceRes.json()
        if (priceData?.ethereum?.usd) {
          ethPrice = priceData.ethereum.usd
          change24h = priceData.ethereum.usd_24h_change || 0
        }
      } catch (priceErr) {
        console.log("[v0 BALANCE API] Price fetch failed:", priceErr)
      }
      
      return NextResponse.json({
        address,
        balanceWei,
        balanceEth: balanceInEth,
        ethPrice,
        change24h,
        usdValue: parseFloat(balanceInEth) * ethPrice,
        network: "ethereum",
      })
    } catch (error: any) {
      lastError = error.message
      console.log(`[v0 BALANCE API] RPC ${rpcUrl} failed: ${lastError}`)
      continue
    }
  }

console.error(`[v0 BALANCE API] All RPCs failed. Last error: ${lastError}`)
  return NextResponse.json(
    {
      error: "Failed to fetch balance from all RPC endpoints",
      lastError,
    },
    { status: 500 }
  )
}
[V0_FILE]typescript:file="middleware.ts" isMerged="true"
import { createServerClient } from "@supabase/ssr"
import { NextResponse, type NextRequest } from "next/server"

export async function middleware(request: NextRequest) {
  // Skip if Supabase env vars are not configured
  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
  const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
  
  if (!supabaseUrl || !supabaseAnonKey) {
    return NextResponse.next()
  }

let supabaseResponse = NextResponse.next({
    request,
  })

const supabase = createServerClient(
    supabaseUrl,
    supabaseAnonKey,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll()
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value }) => request.cookies.set(name, value))
          supabaseResponse = NextResponse.next({
            request,
          })
          cookiesToSet.forEach(({ name, value, options }) =>
            supabaseResponse.cookies.set(name, value, options)
          )
        },
      },
    }
  )

// This will refresh session if expired - required for Server Components
  // https://supabase.com/docs/guides/auth/server-side/nextjs
  await supabase.auth.getUser()

return supabaseResponse
}

export const config = {
  matcher: [
    /*
     * Match all request paths except for the ones starting with:
     * - _next/static (static files)
     * - _next/image (image optimization files)
     * - favicon.ico (favicon file)
     * - public folder
     */
    "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
  ],
}
[V0_FILE]typescriptreact:file="app/admin/transactions/page.tsx" isMerged="true"
"use client"

interface Transaction {
  id: string
  tx_hash: string
  from_address: string
  to_address: string
  amount: string
  type: string
  status: string
  created_at: string
  confirmed_at: string
}

export default function AdminTransactionsPage() {
  const [transactions, setTransactions] = useState<Transaction[]>([])
  const [filteredTransactions, setFilteredTransactions] = useState<Transaction[]>([])
  const [searchQuery, setSearchQuery] = useState("")
  const [loading, setLoading] = useState(true)

useEffect(() => {
    loadTransactions()
  }, [])

useEffect(() => {
    if (searchQuery) {
      const filtered = transactions.filter(
        (tx) =>
          tx.tx_hash?.toLowerCase().includes(searchQuery.toLowerCase()) ||
          tx.from_address?.toLowerCase().includes(searchQuery.toLowerCase()) ||
          tx.to_address?.toLowerCase().includes(searchQuery.toLowerCase()),
      )
      setFilteredTransactions(filtered)
    } else {
      setFilteredTransactions(transactions)
    }
  }, [searchQuery, transactions])

const loadTransactions = async () => {
    try {
      const supabase = createClient()

const { data, error } = await supabase
        .from("transactions")
        .select("*")
        .order("created_at", { ascending: false })
        .limit(100)

if (error) throw error
      setTransactions(data || [])
      setFilteredTransactions(data || [])
    } catch (error) {
      console.error("Failed to load transactions:", error)
    } finally {
      setLoading(false)
    }
  }

return (
    <AdminLayout>
      <div className="space-y-6">
        <div>
          <h1 className="text-3xl font-bold text-gray-900">Transaction Management</h1>
          <p className="text-gray-600 mt-1">Monitor all platform transactions</p>
        </div>

<Card>
          <CardHeader>
            <div className="flex items-center gap-4">
              <div className="flex-1 relative">
                <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 text-gray-400" />
                <Input
                  placeholder="Search by transaction hash or address..."
                  value={searchQuery}
                  onChange={(e) => setSearchQuery(e.target.value)}
                  className="pl-10"
                />
              </div>
            </div>
          </CardHeader>
          <CardContent>
            {loading ? (
              <div className="text-center py-12 text-gray-500">Loading transactions...</div>
            ) : filteredTransactions.length === 0 ? (
              <div className="text-center py-12 text-gray-500">No transactions found</div>
            ) : (
              <div className="overflow-x-auto">
                <table className="w-full">
                  <thead className="border-b border-gray-200">
                    <tr>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">Type</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">Amount</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">From</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">To</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">Status</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">Date</th>
                      <th className="text-left py-3 px-4 text-sm font-semibold text-gray-700">TX Hash</th>
                    </tr>
                  </thead>
                  <tbody className="divide-y divide-gray-200">
                    {filteredTransactions.map((tx) => (
                      <tr key={tx.id} className="hover:bg-gray-50">
                        <td className="py-3 px-4">
                          <div className="flex items-center gap-2">
                            {tx.type === "send" ? (
                              <ArrowUpRight className="w-5 h-5 text-red-500" />
                            ) : (
                              <ArrowDownRight className="w-5 h-5 text-green-500" />
                            )}
                            <span className="text-sm font-medium capitalize">{tx.type}</span>
                          </div>
                        </td>
                        <td className="py-3 px-4 text-sm font-mono font-medium">{tx.amount} ETH</td>
                        <td className="py-3 px-4 text-sm font-mono text-gray-700">
                          {tx.from_address ? `${tx.from_address.slice(0, 6)}...${tx.from_address.slice(-4)}` : "—"}
                        </td>
                        <td className="py-3 px-4 text-sm font-mono text-gray-700">
                          {tx.to_address ? `${tx.to_address.slice(0, 6)}...${tx.to_address.slice(-4)}` : "—"}
                        </td>
                        <td className="py-3 px-4">
                          <span
                            className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${
                              tx.status === "success"
                                ? "bg-green-100 text-green-800"
                                : tx.status === "pending"
                                  ? "bg-yellow-100 text-yellow-800"
                                  : "bg-red-100 text-red-800"
                            }`}
                          >
                            {tx.status}
                          </span>
                        </td>
                        <td className="py-3 px-4 text-sm text-gray-700">{new Date(tx.created_at).toLocaleString()}</td>
                        <td className="py-3 px-4">
                          {tx.tx_hash && (
                            <a
                              href={`https://etherscan.io/tx/${tx.tx_hash}`}
                              target="_blank"
                              rel="noopener noreferrer"
                              className="inline-flex items-center gap-1 text-sm text-blue-600 hover:text-blue-800"
                            >
                              {tx.tx_hash.slice(0, 6)}...
                              <ExternalLink className="w-3 h-3" />
                            </a>
                          )}
                        </td>
                      </tr>
                    ))}
                  </tbody>
                </table>
              </div>
            )}
          </CardContent>
        </Card>

<div className="bg-blue-50 border border-blue-200 rounded-lg p-4">
          <p className="text-sm text-blue-800">
            <strong>Total Transactions:</strong> {filteredTransactions.length}{" "}
            {searchQuery && `(filtered from ${transactions.length})`}
          </p>
        </div>
      </div>
    </AdminLayout>
  )
}
[V0_FILE]typescript:file="app/api/transactions/detect-received/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { createServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"
import { ethers } from "ethers"

export async function POST(request: Request) {
  try {
    const { walletAddress } = await request.json()

if (!walletAddress) {
      return NextResponse.json({ error: "Wallet address required" }, { status: 400 })
    }

console.log("[v0 Detect API] Starting detection for:", walletAddress)

const etherscanUrl = `https://api.etherscan.io/api?module=account&action=txlist&address=${walletAddress}&startblock=0&endblock=99999999&page=1&offset=100&sort=desc`

console.log("[v0 Detect API] Fetching from Etherscan...")

const response = await fetch(etherscanUrl, {
      signal: AbortSignal.timeout(10000), // 10 second timeout
    })

if (!response.ok) {
      console.error("[v0 Detect API] Etherscan HTTP error:", response.status)
      return NextResponse.json({
        success: true,
        newTransactions: 0,
        message: `Etherscan API error: ${response.status}`,
      })
    }

const data = await response.json()
    console.log("[v0 Detect API] Etherscan response status:", data.status)
    console.log("[v0 Detect API] Etherscan message:", data.message)
    console.log("[v0 Detect API] Transaction count:", data.result?.length || 0)

if (data.status !== "1") {
      console.log("[v0 Detect API] API returned error or no data")
      return NextResponse.json({
        success: true,
        newTransactions: 0,
        message: data.message || "No transactions found",
        debug: { status: data.status, message: data.message },
      })
    }

if (!data.result || !Array.isArray(data.result) || data.result.length === 0) {
      console.log("[v0 Detect API] No transactions in result")
      return NextResponse.json({
        success: true,
        newTransactions: 0,
        message: "No transactions found for this address",
      })
    }

const cookieStore = await cookies()
    const supabase = createServerClient(
      process.env.NEXT_PUBLIC_SUPABASE_URL!,
      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
      {
        cookies: {
          getAll() {
            return cookieStore.getAll()
          },
          setAll(cookiesToSet) {
            cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
          },
        },
      },
    )

const {
      data: { user },
    } = await supabase.auth.getUser()

console.log("[v0 Detect API] User authenticated:", !!user)

let savedCount = 0
    let skippedCount = 0
    const lowerWalletAddress = walletAddress.toLowerCase()

console.log("[v0 Detect API] Processing", data.result.length, "transactions...")

for (const tx of data.result) {
      const isIncoming = tx.to.toLowerCase() === lowerWalletAddress
      const isOutgoing = tx.from.toLowerCase() === lowerWalletAddress

if (!isIncoming && !isOutgoing) {
        continue // Skip transactions not related to this wallet
      }

console.log(
        "[v0 Detect API] Found",
        isIncoming ? "incoming" : "outgoing",
        "tx:",
        tx.hash,
        "from",
        tx.from.substring(0, 10),
        "to",
        tx.to.substring(0, 10),
      )

const { data: existing } = await supabase
        .from("transactions")
        .select("id")
        .ilike("tx_hash", tx.hash)
        .maybeSingle()

if (existing) {
        console.log("[v0 Detect API] Transaction already exists:", tx.hash)
        skippedCount++
        continue
      }

const amountInEth = Number.parseFloat(ethers.formatEther(tx.value))

const { error } = await supabase.from("transactions").insert({
        user_id: user?.id || null,
        tx_hash: tx.hash,
        from_address: tx.from,
        to_address: tx.to,
        amount: amountInEth.toString(),
        token: "ETH",
        type: isIncoming ? "receive" : "send",
        status: tx.txreceipt_status === "1" ? "confirmed" : "failed",
        confirmed_at: new Date(Number.parseInt(tx.timeStamp) * 1000).toISOString(),
        created_at: new Date().toISOString(),
      })

if (!error) {
        console.log(
          "[v0 Detect API] ✓ Saved",
          isIncoming ? "incoming" : "outgoing",
          "transaction:",
          tx.hash,
          amountInEth,
          "ETH",
        )
        savedCount++
      } else {
        console.error("[v0 Detect API] Error saving transaction:", tx.hash, error)
      }
    }

console.log(`[v0 Detect API] Complete: ${savedCount} saved, ${skippedCount} skipped`)

return NextResponse.json({
      success: true,
      newTransactions: savedCount,
      skippedCount,
      totalProcessed: data.result.length,
      message:
        savedCount > 0
          ? `Found ${savedCount} new transaction${savedCount !== 1 ? "s" : ""}`
          : "No new transactions found",
    })
  } catch (error: any) {
    console.error("[v0 Detect API] Error:", error.message || error)
    return NextResponse.json({
      success: true,
      newTransactions: 0,
      error: "Failed to detect transactions",
      details: error.message,
    })
  }
}
[V0_FILE]typescriptreact:file="components/simple-transaction-list.tsx" isMerged="true"
"use client"

import { useEffect, useState } from "react"
import { Card } from "@/components/ui/card"
import { createClient } from "@/lib/supabase/client"
import { ArrowUpRight, ArrowDownLeft, ExternalLink, Loader2 } from "lucide-react"
import { Button } from "@/components/ui/button"

interface Transaction {
  tx_hash: string
  from_address: string
  to_address: string
  amount: string
  type: "send" | "receive"
  status: string
  created_at: string
  token: string
}

export function SimpleTransactionList({ walletAddress }: { walletAddress: string }) {
  const [transactions, setTransactions] = useState<Transaction[]>([])
  const [isLoading, setIsLoading] = useState(true)
  const [showAll, setShowAll] = useState(false)
  const supabase = createClient()

useEffect(() => {
    console.log("[v0 SimpleTxList] Component mounted")
    console.log("[v0 SimpleTxList] Received walletAddress prop:", walletAddress)
    console.log("[v0 SimpleTxList] walletAddress type:", typeof walletAddress)
    console.log("[v0 SimpleTxList] walletAddress length:", walletAddress?.length)
  }, [])

const normalizedAddress = walletAddress?.startsWith("0x") ? walletAddress : `0x${walletAddress || ""}`
  const isValidAddress = normalizedAddress && normalizedAddress.length >= 42

useEffect(() => {
    console.log("[v0 SimpleTxList] Normalized address:", normalizedAddress)
    console.log("[v0 SimpleTxList] Is valid address:", isValidAddress)

if (!isValidAddress) {
      console.error("[v0 SimpleTxList] Invalid wallet address, cannot load transactions")
      setIsLoading(false)
      return
    }

loadTransactions()
    detectIncomingTransactions()

const handleTransactionComplete = () => {
      console.log("[v0 SimpleTxList] Transaction complete event received, refreshing...")
      loadTransactions()
    }
    window.addEventListener("transactionComplete", handleTransactionComplete)

const refreshInterval = setInterval(() => {
      console.log("[v0 SimpleTxList] Refresh interval triggered")
      loadTransactions()
    }, 30000)

const detectionInterval = setInterval(() => {
      console.log("[v0 SimpleTxList] Detection interval triggered")
      detectIncomingTransactions()
    }, 45000)

return () => {
      console.log("[v0 SimpleTxList] Component unmounting, clearing intervals")
      clearInterval(refreshInterval)
      clearInterval(detectionInterval)
      window.removeEventListener("transactionComplete", handleTransactionComplete)
    }
  }, [normalizedAddress, isValidAddress])

const detectIncomingTransactions = async () => {
    if (!isValidAddress) {
      console.log("[v0 SimpleTxList] No valid wallet address for detection")
      return
    }

try {
      console.log("[v0 SimpleTxList] Auto-detecting incoming transactions for:", normalizedAddress)

const data = await response.json()
      console.log("[v0 SimpleTxList] Detection response:", data)

if (data.newTransactions > 0) {
        console.log(`[v0 SimpleTxList] Found ${data.newTransactions} new incoming transaction(s)`)
        await loadTransactions()
      } else {
        console.log("[v0 SimpleTxList] No new incoming transactions detected")
      }
    } catch (error) {
      console.error("[v0 SimpleTxList] Auto-detection error:", error)
    }
  }

const loadTransactions = async () => {
    if (!isValidAddress) {
      console.log("[v0 SimpleTxList] No valid wallet address, skipping load")
      setIsLoading(false)
      return
    }

console.log("[v0 SimpleTxList] Loading transactions for:", normalizedAddress)
    setIsLoading(true)

try {
      const walletLower = normalizedAddress.toLowerCase()
      console.log("[v0 SimpleTxList] Querying with lowercase address:", walletLower)

const { data, error } = await supabase
        .from("transactions")
        .select("*")
        .or(`from_address.ilike.%${walletLower}%,to_address.ilike.%${walletLower}%`)
        .order("created_at", { ascending: false })
        .limit(100)

if (error) {
        console.error("[v0 SimpleTxList] Supabase error:", error)
        setIsLoading(false)
        return
      }

console.log("[v0 SimpleTxList] Raw data from Supabase:", data?.length || 0, "transactions")

if (data && data.length > 0) {
        console.log("[v0 SimpleTxList] Sample transaction:", {
          hash: data[0].tx_hash?.substring(0, 10),
          from: data[0].from_address,
          to: data[0].to_address,
          amount: data[0].amount,
        })
      }

const processedTransactions = (data || []).map((tx: any) => {
        const fromLower = tx.from_address?.toLowerCase() || ""
        const isSend = fromLower === walletLower

console.log(
          `[v0 SimpleTxList] Processing tx ${tx.tx_hash?.substring(0, 10)}... - Type: ${isSend ? "send" : "receive"}`,
        )

return {
          ...tx,
          type: isSend ? "send" : "receive",
        }
      })

console.log("[v0 SimpleTxList] Processed transactions:", {
        total: processedTransactions.length,
        send: processedTransactions.filter((t) => t.type === "send").length,
        receive: processedTransactions.filter((t) => t.type === "receive").length,
      })

setTransactions(processedTransactions)
    } catch (error) {
      console.error("[v0 SimpleTxList] Unexpected error:", error)
    } finally {
      setIsLoading(false)
    }
  }

const displayedTransactions = showAll ? transactions : transactions.slice(0, 5)

if (!isValidAddress) {
    return (
      <Card className="p-6">
        <h3 className="text-lg font-semibold mb-4">Transaction History</h3>
        <div className="text-center py-8 text-muted-foreground">
          <p>Invalid wallet address</p>
        </div>
      </Card>
    )
  }

if (isLoading && transactions.length === 0) {
    return (
      <Card className="p-6">
        <div className="flex items-center justify-center gap-2 text-muted-foreground">
          <Loader2 className="w-4 h-4 animate-spin" />
          <span>Loading transactions...</span>
        </div>
      </Card>
    )
  }

return (
    <Card className="p-6">
      <div className="flex items-center justify-between mb-4">
        <h3 className="text-lg font-semibold">Transaction History</h3>
      </div>

{transactions.length === 0 ? (
        <div className="text-center py-8 text-muted-foreground">
          <p>No transactions yet</p>
        </div>
      ) : (
        <div className="space-y-2">
          {displayedTransactions.map((tx) => (
            <div
              key={tx.tx_hash}
              className="flex items-center gap-3 p-3 rounded-lg border hover:bg-muted/50 transition-colors"
            >
              <div
                className={`w-10 h-10 rounded-full flex items-center justify-center ${
                  tx.type === "send" ? "bg-red-500/10" : "bg-green-500/10"
                }`}
              >
                {tx.type === "send" ? (
                  <ArrowUpRight className="w-5 h-5 text-red-500" />
                ) : (
                  <ArrowDownLeft className="w-5 h-5 text-green-500" />
                )}
              </div>
              <div className="flex-1 min-w-0">
                <div className="flex items-center gap-2">
                  <p className="font-medium capitalize">{tx.type}</p>
                  <span className="text-xs px-2 py-0.5 rounded-full bg-muted">{tx.status}</span>
                </div>
                <p className="text-sm text-muted-foreground truncate">
                  {tx.type === "send" ? `To: ${tx.to_address}` : `From: ${tx.from_address}`}
                </p>
              </div>
              <div className="text-right">
                <p className="font-medium">
                  {tx.type === "send" ? "-" : "+"}
                  {tx.amount} {tx.token || "ETH"}
                </p>
                <a
                  href={`https://etherscan.io/tx/${tx.tx_hash}`}
                  target="_blank"
                  rel="noopener noreferrer"
                  className="text-xs text-primary hover:underline inline-flex items-center gap-1"
                >
                  View <ExternalLink className="w-3 h-3" />
                </a>
              </div>
            </div>
          ))}

{transactions.length > 5 && !showAll && (
            <Button onClick={() => setShowAll(true)} variant="outline" className="w-full mt-4">
              View All {transactions.length} Transactions
            </Button>
          )}

{showAll && (
            <Button onClick={() => setShowAll(false)} variant="outline" className="w-full mt-4">
              Show Less
            </Button>
          )}
        </div>
      )}
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/transaction-status-toast.tsx" isMerged="true"
"use client"

import { useEffect } from "react"
import { Card } from "@/components/ui/card"
import { CheckCircle2, AlertCircle, Loader2, ExternalLink } from "lucide-react"
import { Button } from "@/components/ui/button"

interface TransactionStatusToastProps {
  status: "pending" | "success" | "error" | null
  message?: string
  txHash?: string
  onClose: () => void
}

export function TransactionStatusToast({ status, message, txHash, onClose }: TransactionStatusToastProps) {
  useEffect(() => {
    if (status === "success") {
      const timer = setTimeout(onClose, 5000)
      return () => clearTimeout(timer)
    }
  }, [status, onClose])

if (!status) return null

const getStatusConfig = () => {
    switch (status) {
      case "pending":
        return {
          icon: <Loader2 className="w-5 h-5 animate-spin text-blue-500" />,
          title: "Transaction Pending",
          message: message || "Processing your transaction...",
          bg: "bg-blue-500/10 border-blue-500/20",
        }
      case "success":
        return {
          icon: <CheckCircle2 className="w-5 h-5 text-green-500" />,
          title: "Transaction Successful",
          message: message || "Your transaction has been confirmed",
          bg: "bg-green-500/10 border-green-500/20",
        }
      case "error":
        return {
          icon: <AlertCircle className="w-5 h-5 text-red-500" />,
          title: "Transaction Failed",
          message: message || "Something went wrong. Please try again.",
          bg: "bg-red-500/10 border-red-500/20",
        }
    }
  }

const config = getStatusConfig()

return (
    <div className="fixed top-4 right-4 z-[9999] animate-in slide-in-from-top-5">
      <Card className={`p-4 border ${config.bg} shadow-lg max-w-sm`}>
        <div className="flex items-start gap-3">
          <div className="flex-shrink-0">{config.icon}</div>
          <div className="flex-1 min-w-0">
            <p className="font-semibold text-sm mb-1">{config.title}</p>
            <p className="text-xs text-muted-foreground">{config.message}</p>
            {txHash && (
              <Button
                variant="link"
                size="sm"
                className="h-auto p-0 mt-2 text-xs"
                onClick={() => window.open(`https://etherscan.io/tx/${txHash}`, "_blank")}
              >
                View on Etherscan <ExternalLink className="w-3 h-3 ml-1" />
              </Button>
            )}
          </div>
          <button onClick={onClose} className="flex-shrink-0 text-muted-foreground hover:text-foreground">
            <span className="sr-only">Close</span>×
          </button>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescript:file="lib/builtin-wallet-provider.ts" isMerged="true"
import { ethers } from "ethers"

// Ethereum Mainnet RPC endpoints
const MAINNET_RPC_URLS = [
  "https://eth.llamarpc.com",
  "https://ethereum-rpc.publicnode.com",
  "https://cloudflare-eth.com",
  "https://1rpc.io/eth",
  "https://rpc.ankr.com/eth",
]

// Create a provider that races multiple endpoints
async function createRacingProvider(rpcUrls: string[], timeoutMs = 8000): Promise<ethers.JsonRpcProvider> {
  // Try all endpoints simultaneously and use the first one that responds
  const racePromises = rpcUrls.map(async (url, index) => {
    const provider = new ethers.JsonRpcProvider(url)
    try {
      // Test the connection with a simple call
      const timeoutPromise = new Promise<never>((_, reject) => 
        setTimeout(() => reject(new Error(`Timeout: ${url}`)), timeoutMs)
      )
      await Promise.race([provider.getBlockNumber(), timeoutPromise])
      console.log(`[v0 RPC] Endpoint ${index + 1} responded: ${url.slice(0, 35)}...`)
      return { provider, url, index }
    } catch (e) {
      throw new Error(`Failed: ${url}`)
    }
  })

try {
    const winner = await Promise.any(racePromises)
    console.log(`[v0 RPC] Using fastest endpoint: ${winner.url.slice(0, 35)}...`)
    return winner.provider
  } catch (e) {
    // All failed, return the first one and hope for the best
    console.log(`[v0 RPC] All endpoints failed, using first as fallback`)
    return new ethers.JsonRpcProvider(rpcUrls[0])
  }
}

// Try providers sequentially with quick timeouts
async function tryProvidersSequentially(
  rpcUrls: string[], 
  operation: (provider: ethers.JsonRpcProvider) => Promise<any>,
  timeoutMs = 8000
): Promise<any> {
  const errors: string[] = []
  
  for (let i = 0; i < Math.min(rpcUrls.length, 5); i++) {
    const url = rpcUrls[i]
    try {
      console.log(`[v0 RPC] Attempting RPC ${i + 1}: ${url.slice(0, 50)}...`)
      const provider = new ethers.JsonRpcProvider(url, undefined, {
        staticNetwork: true,
        batchMaxCount: 1,
      })
      
      const timeoutPromise = new Promise<never>((_, reject) => 
        setTimeout(() => reject(new Error("timeout")), timeoutMs)
      )
      
      const result = await Promise.race([operation(provider), timeoutPromise])
      console.log(`[v0 RPC] Success with RPC ${i + 1}`)
      return result
    } catch (error: any) {
      const msg = error?.message?.slice(0, 60) || "unknown"
      console.log(`[v0 RPC] RPC ${i + 1} failed: ${msg}`)
      errors.push(`${i + 1}: ${msg}`)
      // Continue to next endpoint immediately
    }
  }
  
  throw new Error(`All RPCs failed: ${errors.join(", ")}`)
}

export class BuiltInWalletProvider {
  private wallet: ethers.Wallet | null = null
  private rpcUrls: string[]
  private chainId: number

constructor(walletOrRpcUrl?: ethers.Wallet | string, rpcUrlOrChainId?: string | number, chainIdParam?: number) {
    if (walletOrRpcUrl instanceof ethers.Wallet) {
      this.wallet = walletOrRpcUrl
      this.chainId = chainIdParam || 1 // Ethereum Mainnet
    } else {
      this.chainId = typeof rpcUrlOrChainId === "number" ? rpcUrlOrChainId : 1 // Ethereum Mainnet
    }
    
    // Use Mainnet RPC URLs
    this.rpcUrls = MAINNET_RPC_URLS
  }

async initialize(privateKey: string) {
    console.log("[v0] BuiltInWalletProvider.initialize called")
    try {
      this.wallet = new ethers.Wallet(privateKey)
      console.log("[v0] Wallet initialized successfully, address:", this.wallet.address)
    } catch (error) {
      console.error("[v0] Error creating wallet from private key:", error)
      throw new Error("Failed to initialize wallet from private key")
    }
  }

setWallet(wallet: ethers.Wallet) {
    this.wallet = wallet
  }

async request({ method, params }: { method: string; params?: any[] }): Promise<any> {
    if (!this.wallet) {
      throw new Error("Wallet not initialized")
    }

const rpcUrls = this.rpcUrls

switch (method) {
      case "eth_requestAccounts":
      case "eth_accounts":
        return [this.wallet.address]

case "eth_getBalance":
        console.log("[v0 WALLET] eth_getBalance called for:", params?.[0] || this.wallet!.address)
        return await tryProvidersSequentially(rpcUrls, async (provider) => {
          const address = params?.[0] || this.wallet!.address
          console.log("[v0 WALLET] Fetching balance for address:", address)
          const balance = await provider.getBalance(address)
          console.log("[v0 WALLET] Raw balance:", balance.toString())
          const hexBalance = `0x${balance.toString(16)}`
          console.log("[v0 WALLET] Hex balance:", hexBalance)
          return hexBalance
        })

case "eth_getTransactionCount":
        return await tryProvidersSequentially(rpcUrls, async (provider) => {
          const txCount = await provider.getTransactionCount(
            params?.[0] || this.wallet!.address, 
            params?.[1] || "latest"
          )
          return `0x${txCount.toString(16)}`
        })

case "eth_call":
        return await tryProvidersSequentially(rpcUrls, async (provider) => {
          return await provider.call({
            to: params?.[0]?.to,
            data: params?.[0]?.data,
          })
        })

case "eth_estimateGas":
        try {
          return await tryProvidersSequentially(rpcUrls, async (provider) => {
            const txParams: any = {
              from: params?.[0]?.from || this.wallet!.address,
              to: params?.[0]?.to,
              value: params?.[0]?.value ? BigInt(params[0].value) : undefined,
              data: params?.[0]?.data || "0x",
            }
            const gasEstimate = await provider.estimateGas(txParams)
            return `0x${gasEstimate.toString(16)}`
          })
        } catch (error: any) {
          // Return default for simple ETH transfers
          if (params?.[0]?.data === "0x" || !params?.[0]?.data) {
            return "0x5208" // 21000 in hex
          }
          throw error
        }

case "eth_sendTransaction":
        return await tryProvidersSequentially(rpcUrls, async (provider) => {
          const connectedWallet = this.wallet!.connect(provider)
          
          const txToSend: any = {
            to: params?.[0]?.to,
            value: params?.[0]?.value ? BigInt(params[0].value) : undefined,
            data: params?.[0]?.data || "0x",
            maxFeePerGas: params?.[0]?.maxFeePerGas ? BigInt(params[0].maxFeePerGas) : undefined,
            maxPriorityFeePerGas: params?.[0]?.maxPriorityFeePerGas ? BigInt(params[0].maxPriorityFeePerGas) : undefined,
            gasLimit: params?.[0]?.gas ? BigInt(params[0].gas) : 21000n,
          }
          
          const tx = await connectedWallet.sendTransaction(txToSend)
          return tx.hash
        }, 20000) // 20 second timeout for transactions

case "personal_sign":
      case "eth_sign":
        const message = params?.[0]
        if (!message) throw new Error("No message to sign")
        const signature = await this.wallet.signMessage(ethers.getBytes(message))
        return signature

case "eth_chainId":
        return `0x${this.chainId.toString(16)}`

default:
        throw new Error(`Method ${method} not supported by built-in wallet`)
    }
  }
}
[V0_FILE]typescriptreact:file="app/page.tsx" isMerged="true"
"use client"

import { useState, useEffect, useRef, Suspense } from "react"
import { WalletConnect } from "@/components/wallet-connect"
import { WalletDashboard } from "@/components/wallet-dashboard"
import { SendInterface } from "@/components/send-interface"
import { ReceiveInterface } from "@/components/receive-interface"
import { SwapInterface } from "@/components/swap-interface"
import { Plus } from "lucide-react"
import { Button } from "@/components/ui/button"
import Image from "next/image"
import { TokenManager } from "@/components/token-manager"
import { TransactionHistory } from "@/components/transaction-history"
import { MessageSigner } from "@/components/message-signer"
import { SocialShare } from "@/components/social-share"
import { FooterDisclaimer } from "@/components/footer-disclaimer"
import { ComplianceModal } from "@/components/compliance-modal"
import { checkAndTrackReferral, trackReferralSignup } from "@/lib/referral"
import { createClient } from "@/lib/supabase/client"
import { SecurityBanner } from "@/components/security-banner"
import { CryptoTicker } from "@/components/crypto-ticker"
import { ethers } from "ethers"
import { AddMoneyInterface } from "@/components/add-money-interface"
import { UnifiedAuthWallet } from "@/components/unified-auth-wallet"
import { PortfolioAnalytics } from "@/components/portfolio-analytics"
import { BuiltInWalletProvider } from "@/lib/builtin-wallet-provider"

// Safe storage helpers to prevent crashes
const safeGetItem = (storage: Storage | null, key: string): string | null => {
  try {
    if (typeof window === "undefined" || !storage) return null
    return storage.getItem(key)
  } catch (e) {
    console.error("[v0] Storage access error:", e)
    return null
  }
}

const safeSetItem = (storage: Storage | null, key: string, value: string): boolean => {
  try {
    if (typeof window === "undefined" || !storage) return false
    storage.setItem(key, value)
    return true
  } catch (e) {
    console.error("[v0] Storage write error:", e)
    return false
  }
}

const safeRemoveItem = (storage: Storage | null, key: string): boolean => {
  try {
    if (typeof window === "undefined" || !storage) return false
    storage.removeItem(key)
    return true
  } catch (e) {
    console.error("[v0] Storage remove error:", e)
    return false
  }
}

const safeJsonParse = <T,>(str: string | null, fallback: T): T => {
  if (!str) return fallback
  try {
    return JSON.parse(str) as T
  } catch (e) {
    console.error("[v0] JSON parse error:", e)
    return fallback
  }
}

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

export default function Home() {
  const [connectedWallets, setConnectedWallets] = useState<ConnectedWallet[]>([])
  const [activeWallet, setActiveWallet] = useState<ConnectedWallet | null>(null)
  const [activeTab, setActiveTab] = useState<
    "wallet" | "send" | "receive" | "swap" | "tokens" | "history" | "sign" | "addmoney" | "achievements" | "analytics"
  >("wallet")
  const [showWalletModal, setShowWalletModal] = useState(false)
  const [activeProvider, setActiveProvider] = useState<any>(null)
  const [isAutoReconnecting, setIsAutoReconnecting] = useState(true)
  const [showAuthModal, setShowAuthModal] = useState(false)
  const [unlockedWalletData, setUnlockedWalletData] = useState<any>(null)
  const supabase = createClient()

const connectedWalletsRef = useRef<ConnectedWallet[]>([])

useEffect(() => {
    connectedWalletsRef.current = connectedWallets
  }, [connectedWallets])

useEffect(() => {
    const autoReconnect = async () => {
      setIsAutoReconnecting(true)
      console.log("[v0 AUTO-RECONNECT] Starting auto-reconnect...")

try {
        const {
          data: { user },
        } = await supabase.auth.getUser()

if (user) {
          console.log("[v0 AUTO-RECONNECT] Found authenticated user:", user.id)

const { data: profileData } = await supabase
            .from("profiles")
            .select("wallet_address, builtin_wallet_address, has_builtin_wallet, encrypted_wallet")
            .eq("id", user.id)
            .single()

console.log("[v0 AUTO-RECONNECT] Profile data loaded:", {
            hasWallet: !!profileData?.wallet_address,
            address: profileData?.wallet_address?.slice(0, 10) + "...",
          })

if (profileData?.wallet_address) {
            const dbWalletAddress = profileData.wallet_address

console.log("[v0 AUTO-RECONNECT] Creating built-in wallet info")

let balanceEth = "0.0000"
            // Use server-side API route to fetch balance
            try {
              console.log("[v0 AUTO-RECONNECT] Fetching balance via API...")
              const response = await fetch(`/api/balance?address=${dbWalletAddress}`)
              const data = await response.json()
              console.log("[v0 AUTO-RECONNECT] Balance API response:", JSON.stringify(data))
              
              if (data.balanceEth) {
                balanceEth = parseFloat(data.balanceEth).toFixed(4)
                console.log("[v0 AUTO-RECONNECT] Balance from API:", balanceEth)
              }
            } catch (error) {
              console.log("[v0 AUTO-RECONNECT] Balance API failed:", error)
            }

const walletInfo: ConnectedWallet = {
              address: dbWalletAddress,
              balance: balanceEth,
              provider: "builtin",
              name: "Built-in Wallet",
            }

console.log("[v0 AUTO-RECONNECT] Built-in wallet created:", walletInfo.address.slice(0, 10) + "...")
            console.log("[v0 AUTO-RECONNECT] About to call handleConnect...")

// Use Ethereum Mainnet RPC for the provider
            const rpcProvider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")
            setActiveProvider(rpcProvider)

setConnectedWallets([walletInfo])
            setActiveWallet(walletInfo)
            console.log("[v0 AUTO-RECONNECT] Built-in wallet added to state")

setTimeout(async () => {
              console.log("[v0 AUTO-RECONNECT] Now checking for external wallets...")
              await checkAndReconnectExternalWallet()
            }, 1000)

// Check if wallet needs to be unlocked
            const walletSession = safeGetItem(typeof window !== "undefined" ? sessionStorage : null, "linkficrypto_wallet_session")
            if (!walletSession || walletSession === "") {
              console.log("[v0 AUTO-RECONNECT] No session found, showing auth modal for unlock")
              setShowAuthModal(true)
            }
          } else {
            console.log("[v0 AUTO-RECONNECT] No wallet in database, showing auth modal")
            setShowAuthModal(true)
          }
        } else {
          console.log("[v0 AUTO-RECONNECT] No authenticated user, checking for session storage wallet...")
          
          // Check for built-in wallet in session storage (even without Supabase auth)
          const storedWallet = sessionStorage.getItem("unlockedWallet") || sessionStorage.getItem("linkficrypto_wallet_session")
          
          if (storedWallet) {
            try {
              const parsed = JSON.parse(storedWallet)
              if (parsed.privateKey) {
                const wallet = new ethers.Wallet(parsed.privateKey)
                const walletAddress = wallet.address
                console.log("[v0 AUTO-RECONNECT] Found wallet in session storage:", walletAddress.slice(0, 10) + "...")
                
                // Fetch balance using API route
                let balanceEth = "0.0000"
                try {
                  const response = await fetch(`/api/balance?address=${walletAddress}`)
                  const data = await response.json()
                  if (data.balanceEth) {
                    balanceEth = parseFloat(data.balanceEth).toFixed(4)
                    console.log("[v0 AUTO-RECONNECT] Balance from API:", balanceEth)
                  }
                } catch {
                  console.log("[v0 AUTO-RECONNECT] Balance API failed")
                }

const walletInfo: ConnectedWallet = {
                  address: walletAddress,
                  balance: balanceEth,
                  provider: "builtin",
                  name: "Built-in Wallet",
                }

// Set up provider and wallet
                const builtInProvider = new BuiltInWalletProvider(wallet, undefined, 1)
                ;(window as any).builtInWalletProvider = builtInProvider
                setActiveProvider(builtInProvider as any)
                setConnectedWallets([walletInfo])
                setActiveWallet(walletInfo)
                
                console.log("[v0 AUTO-RECONNECT] Session wallet restored successfully")
                return
              }
            } catch (e) {
              console.error("[v0 AUTO-RECONNECT] Error parsing session wallet:", e)
            }
          }
          
          // Fall back to checking external wallets
          console.log("[v0 AUTO-RECONNECT] No session wallet, checking for external wallets only")
          await checkAndReconnectExternalWallet()
        }
      } catch (error) {
        console.error("[v0 AUTO-RECONNECT] Error during auto-reconnect:", error)
      } finally {
        setIsAutoReconnecting(false)
        console.log("[v0 AUTO-RECONNECT] Auto-reconnect complete")
      }
    }

const checkAndReconnectExternalWallet = async () => {
      console.log("[v0 EXTERNAL] Checking for previous external wallet connections...")
      const history = safeGetItem(typeof window !== "undefined" ? localStorage : null, "wallet_history")

if (!history) {
        console.log("[v0 EXTERNAL] No wallet history found")
        return
      }

try {
        const wallets = safeJsonParse<any[]>(history, [])
        console.log("[v0 EXTERNAL] Found history:", wallets.length, "wallet(s)")

for (const historicalWallet of wallets) {
          console.log("[v0 EXTERNAL] Checking wallet:", historicalWallet.name, historicalWallet.provider)

if (historicalWallet.provider === "builtin") {
            console.log("[v0 EXTERNAL] Skipping built-in wallet from history")
            continue
          }

let providerToCheck = null

if (historicalWallet.provider === "metamask" && window.ethereum?.isMetaMask) {
            providerToCheck = window.ethereum
          } else if (historicalWallet.provider === "coinbase" && window.ethereum?.isCoinbaseWallet) {
            providerToCheck = window.ethereum
          } else if (historicalWallet.provider === "phantom" && window.phantom?.ethereum) {
            providerToCheck = window.phantom.ethereum
          } else if (historicalWallet.provider === "okx" && window.okxwallet) {
            providerToCheck = window.okxwallet
          } else if (historicalWallet.provider === "binance" && window.BinanceChain) {
            providerToCheck = window.BinanceChain
          } else if (window.ethereum) {
            providerToCheck = window.ethereum
          }

if (providerToCheck) {
            try {
              console.log("[v0 EXTERNAL] Provider found, checking accounts...")
              const accounts = await providerToCheck.request({ method: "eth_accounts" })

if (accounts && accounts.length > 0) {
                const connectedAddress = accounts[0]
                console.log("[v0 EXTERNAL] Wallet is still connected:", connectedAddress.slice(0, 10) + "...")

const balanceHex = await providerToCheck.request({
                  method: "eth_getBalance",
                  params: [connectedAddress, "latest"],
                })
                const balanceWei = Number.parseInt(balanceHex, 16)
                const balanceEth = (balanceWei / 1e18).toFixed(4)

const externalWalletInfo: ConnectedWallet = {
                  address: connectedAddress,
                  balance: balanceEth,
                  provider: historicalWallet.provider,
                  name: historicalWallet.name,
                }

console.log("[v0 EXTERNAL] Adding external wallet to state...")
                setActiveProvider(providerToCheck)

setConnectedWallets((prev) => {
                  const exists = prev.some((w) => w.address.toLowerCase() === connectedAddress.toLowerCase())
                  if (exists) {
                    console.log("[v0 EXTERNAL] Wallet already in array, skipping")
                    return prev
                  }
                  console.log("[v0 EXTERNAL] Adding wallet. New total:", prev.length + 1)
                  return [...prev, externalWalletInfo]
                })

// Don't set as active wallet - keep built-in wallet active
                console.log("[v0 EXTERNAL] External wallet added successfully")
                break // Only reconnect one external wallet
              } else {
                console.log("[v0 EXTERNAL] No accounts found for this wallet")
              }
            } catch (error) {
              console.log("[v0 EXTERNAL] Failed to reconnect wallet:", error)
            }
          } else {
            console.log("[v0 EXTERNAL] Provider not available for:", historicalWallet.provider)
          }
        }
      } catch (error) {
        console.error("[v0 EXTERNAL] Error checking external wallets:", error)
      }

console.log("[v0 EXTERNAL] External wallet check complete")
    }

autoReconnect()
  }, [])

useEffect(() => {
    console.log("[v0] Component mounted, refreshing history")
  }, [])

useEffect(() => {
    console.log("[v0] Connected wallets changed:", connectedWallets.length)
    connectedWallets.forEach((wallet, index) => {
      console.log(`[v0] Wallet ${index + 1}:`, wallet.name, wallet.address.slice(0, 8) + "...")
    })
  }, [connectedWallets])

useEffect(() => {
    checkAndTrackReferral()
  }, [])

const saveToHistory = (wallet: ConnectedWallet) => {
    if (typeof window === "undefined") return

try {
      const HISTORY_KEY = "wallet_history"
      const history = safeGetItem(localStorage, HISTORY_KEY)
      const historyArray = safeJsonParse<any[]>(history, [])

const filtered = historyArray.filter((item: any) => item.address.toLowerCase() !== wallet.address.toLowerCase())

const newHistory = [
        {
          address: wallet.address,
          provider: wallet.provider,
          name: wallet.name,
          lastConnected: Date.now(),
        },
        ...filtered,
      ].slice(0, 10)

safeSetItem(localStorage, HISTORY_KEY, JSON.stringify(newHistory))
    } catch (error) {
      console.error("[v0] Error saving to history:", error)
    }
  }

const handleConnect = (wallet: ConnectedWallet) => {
    return new Promise<void>((resolve) => {
      console.log("[v0 PAGE] ========== handleConnect START ==========")
      console.log("[v0 PAGE] Wallet to connect:", wallet.name, wallet.provider, wallet.address.slice(0, 8) + "...")

try {
        saveToHistory(wallet)

const pendingReferral = sessionStorage.getItem("pending_referral")
        if (pendingReferral) {
          trackReferralSignup(pendingReferral, wallet.address)
          sessionStorage.removeItem("pending_referral")
        }

if (wallet.provider !== "builtin") {
          let providerToSet = null

if (wallet.provider === "metamask" && window.ethereum?.isMetaMask) {
            providerToSet = window.ethereum
          } else if (wallet.provider === "coinbase" && window.ethereum?.isCoinbaseWallet) {
            providerToSet = window.ethereum
          } else if (wallet.provider === "phantom" && window.phantom?.ethereum) {
            providerToSet = window.phantom.ethereum
          } else if (wallet.provider === "okx" && window.okxwallet) {
            providerToSet = window.okxwallet
          } else if (wallet.provider === "binance" && window.BinanceChain) {
            providerToSet = window.BinanceChain
          } else if (window.ethereum) {
            providerToSet = window.ethereum
          }

if (providerToSet) {
            console.log("[v0 PAGE] Setting external wallet provider:", wallet.provider)
            setActiveProvider(providerToSet)
          } else {
            console.log("[v0 PAGE] WARNING: No provider found for external wallet!")
          }
        } else {
          if (typeof window !== "undefined") {
            const unlockedWallet = safeGetItem(sessionStorage, "unlockedWallet")
            if (unlockedWallet) {
              try {
                const { privateKey } = safeJsonParse<{ privateKey?: string }>(unlockedWallet, {})
                const builtInProvider = new BuiltInWalletProvider()
                builtInProvider
                  .initialize(privateKey)
                  .then(() => {
                    console.log("[v0 PAGE] BuiltInWalletProvider initialized successfully")
                    setActiveProvider(builtInProvider)
                    // Store in window for SendInterface fallback
                    ;(window as any).builtInWalletProvider = builtInProvider
                    setUnlockedWalletData({ privateKey })
                  })
                  .catch((error) => {
                    console.error("[v0 PAGE] Error initializing BuiltInWalletProvider:", error)
                    // Fallback to Ethereum Mainnet RPC provider for read-only operations
                    const rpcProvider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")
                    setActiveProvider(rpcProvider)
                  })
              } catch (error) {
                console.error("[v0 PAGE] Error parsing unlocked wallet:", error)
                // Fallback to Ethereum Mainnet RPC provider
                const rpcProvider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")
                setActiveProvider(rpcProvider)
              }
            } else {
              console.log("[v0 PAGE] No unlocked wallet found, using RPC provider")
              const rpcProvider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")
              setActiveProvider(rpcProvider)
            }
          }
        }

const alreadyExists = connectedWalletsRef.current.some(
          (w) => w.address.toLowerCase() === wallet.address.toLowerCase(),
        )

if (alreadyExists) {
          console.log(
            "[v0 PAGE] Wallet already exists, just switching active. Total:",
            connectedWalletsRef.current.length,
          )
          setActiveWallet(wallet)
          resolve()
          console.log("[v0 PAGE] ========== handleConnect END (existing wallet) ==========")
          return
        }

const updatedWallets = [...connectedWalletsRef.current, wallet]
        connectedWalletsRef.current = updatedWallets

console.log("[v0 PAGE] Adding new wallet. New total:", updatedWallets.length)
        updatedWallets.forEach((w, i) => console.log(`  ${i + 1}. ${w.name} - ${w.address.slice(0, 8)}...`))

setConnectedWallets(updatedWallets)
        setActiveWallet(wallet)
        setShowWalletModal(false)

resolve()
        console.log("[v0 PAGE] ========== handleConnect END ==========")
      } catch (error) {
        console.error("[v0 PAGE] Error in handleConnect:", error)
        resolve()
      }
    })
  }

const handleDisconnect = (address: string) => {
    setConnectedWallets((prev) => prev.filter((w) => w.address !== address))
    if (activeWallet?.address === address) {
      const remaining = connectedWallets.filter((w) => w.address !== address)
      setActiveWallet(remaining.length > 0 ? remaining[0] : null)
    }
  }

const handleAuthSuccess = async () => {
    console.log("[v0 PAGE] ========== handleAuthSuccess START ==========")
    setShowAuthModal(false)

try {
      const walletSession = safeGetItem(typeof window !== "undefined" ? sessionStorage : null, "linkficrypto_wallet_session")

if (walletSession) {
        const { address } = safeJsonParse<{ address?: string }>(walletSession, {})
        if (!address) {
          console.log("[v0 PAGE] No address in wallet session")
          return
        }
        console.log("[v0 PAGE] Loading authenticated wallet:", address)

// Use server-side API route for balance
        let balanceEth = "0.0000"
        console.log("[v0 PAGE] Fetching balance for:", address)
        try {
          const response = await fetch(`/api/balance?address=${address}`)
          const data = await response.json()
          console.log("[v0 PAGE] Balance API response:", JSON.stringify(data))
          
          if (data.balanceEth) {
            balanceEth = parseFloat(data.balanceEth).toFixed(4)
            console.log("[v0 PAGE] Balance from API:", balanceEth)
          }
        } catch (error) {
          console.log("[v0 PAGE] Balance API failed:", error)
        }

const walletInfo = {
          address,
          balance: balanceEth,
          provider: "builtin" as const,
          name: "Built-in Wallet",
        }

console.log("[v0 PAGE] Built-in wallet info:", walletInfo)

// Use handleConnect to properly add the wallet
        await handleConnect(walletInfo)
      }
    } catch (error) {
      console.error("[v0 PAGE] Error loading wallet after auth:", error)
    }

console.log("[v0 PAGE] ========== handleAuthSuccess END ==========")
  }

const handleSwitchWallet = async (wallet: ConnectedWallet) => {
    console.log("[v0 PAGE] ========== handleSwitchWallet START ==========")
    console.log("[v0 PAGE] Switching to:", wallet.name, wallet.address.slice(0, 8) + "...")

setActiveWallet(wallet)

if (wallet.provider === "builtin") {
      console.log("[v0 PAGE] Switching to built-in wallet, setting Ethereum Mainnet RPC provider")
      const rpcProvider = new ethers.JsonRpcProvider("https://eth.llamarpc.com")
      setActiveProvider(rpcProvider)

const walletSession = safeGetItem(typeof window !== "undefined" ? sessionStorage : null, "linkficrypto_wallet_session")
      if (walletSession) {
        try {
          const { privateKey } = safeJsonParse<{ privateKey?: string }>(walletSession, {})
          if (privateKey) {
            const builtInProvider = new BuiltInWalletProvider()
            await builtInProvider.initialize(privateKey)
            ;(window as any).builtInWalletProvider = builtInProvider
            console.log("[v0 PAGE] Built-in wallet provider reinitialized")
            setUnlockedWalletData({ privateKey })
          }
        } catch (error) {
          console.error("[v0 PAGE] Error reinitializing built-in provider:", error)
        }
      }
    } else {
      let providerToSet = null

if (wallet.provider === "metamask" && window.ethereum?.isMetaMask) {
        providerToSet = window.ethereum
      } else if (wallet.provider === "coinbase" && window.ethereum?.isCoinbaseWallet) {
        providerToSet = window.ethereum
      } else if (wallet.provider === "phantom" && window.phantom?.ethereum) {
        providerToSet = window.phantom.ethereum
      } else if (wallet.provider === "okx" && window.okxwallet) {
        providerToSet = window.okxwallet
      } else if (wallet.provider === "binance" && window.BinanceChain) {
        providerToSet = window.BinanceChain
      } else if (window.ethereum) {
        providerToSet = window.ethereum
      }

if (providerToSet) {
        console.log("[v0 PAGE] Switching to external wallet, setting provider:", wallet.provider)
        setActiveProvider(providerToSet)
      } else {
        console.error("[v0 PAGE] WARNING: No provider found for external wallet:", wallet.provider)
      }
    }

console.log("[v0 PAGE] ========== handleSwitchWallet END ==========")
  }

const isConnected = connectedWallets.length > 0 && activeWallet !== null

if (isAutoReconnecting) {
    return (
      <div className="min-h-screen bg-background">
        <header className="border-b border-border">
          <div className="container mx-auto px-4 py-6">
            <div className="flex items-center justify-center">
              <Image
                src="/images/img-0193.jpeg"
                alt="LinkFiCrypto"
                width={400}
                height={100}
                className="h-20 w-auto"
                priority
              />
            </div>
          </div>
        </header>
        <main className="container mx-auto px-4 py-8 md:py-16">
          <div className="flex items-center justify-center min-h-[400px]">
            <div className="text-center">
              <div className="w-12 h-12 border-4 border-primary border-t-transparent rounded-full animate-spin mx-auto mb-4"></div>
              <p className="text-muted-foreground">Reconnecting to your wallet...</p>
            </div>
          </div>
        </main>
      </div>
    )
  }

return (
    <div className="min-h-screen bg-background">
      <header className="border-b border-border">
        <div className="container mx-auto px-3 py-3">
          <div className="flex items-center justify-center">
            <Image
              src="/images/img-0193.jpeg"
              alt="LinkFiCrypto"
              width={400}
              height={100}
              className="h-20 w-auto max-w-[350px] sm:max-w-[400px] md:max-w-[450px]"
              priority
            />
          </div>
        </div>
      </header>

{isConnected && <SecurityBanner />}

<main className="container mx-auto px-3 py-3 md:px-4 md:py-6">
        {!isConnected ? (
          <div className="max-w-4xl mx-auto min-h-[60vh] flex items-center justify-center relative">
            <UnifiedAuthWallet onSuccess={handleAuthSuccess} />
            <ComplianceModal />
          </div>
        ) : (
          <div className="max-w-6xl mx-auto">
            {showAuthModal && (
              <div className="fixed inset-0 bg-black/50 z-50 flex items-center justify-center p-4">
                <div className="bg-background rounded-lg max-w-md w-full">
                  <UnifiedAuthWallet onSuccess={handleAuthSuccess} />
                </div>
              </div>
            )}

<div className="space-y-2 mb-4 px-2">
              <Button
                size="lg"
                onClick={() => {
                  console.log("[v0] Connect External Wallet button clicked in page.tsx")
                  setShowWalletModal(true)
                }}
                className="w-full h-14 text-lg font-semibold bg-black text-white hover:bg-black/90"
              >
                <Plus className="w-5 h-5 mr-2" />
                Connect External Wallet
              </Button>

<WalletConnect
              onConnect={handleConnect}
              connectedWallets={connectedWallets}
              isOpen={showWalletModal}
              onClose={() => setShowWalletModal(false)}
            />

{activeTab === "wallet" && (
              <WalletDashboard
                walletAddress={activeWallet.address}
                connectedWallets={connectedWallets}
                activeWallet={activeWallet}
                onSwitchWallet={handleSwitchWallet}
                onDisconnectWallet={handleDisconnect}
                activeProvider={activeProvider}
              />
            )}
            {activeTab === "analytics" && (
              <PortfolioAnalytics walletAddress={activeWallet.address} provider={activeProvider} />
            )}
            {activeTab === "addmoney" && <AddMoneyInterface address={activeWallet.address} />}
            {activeTab === "send" && (
              <SendInterface
                address={activeWallet.address}
                balance={activeWallet.balance}
                token="ETH"
                provider={activeProvider}
                unlockedWalletData={unlockedWalletData}
              />
            )}
            {activeTab === "receive" && <ReceiveInterface address={activeWallet.address} />}
            {activeTab === "swap" && <SwapInterface address={activeWallet.address} />}
            {activeTab === "tokens" && <TokenManager walletAddress={activeWallet.address} provider={activeProvider} />}
            {activeTab === "history" && (
              <TransactionHistory walletAddress={activeWallet.address} provider={activeProvider} />
            )}
            {activeTab === "sign" && <MessageSigner walletAddress={activeWallet.address} provider={activeProvider} />}
          </div>
        )}
      </main>
      <FooterDisclaimer />
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/auth/forgot-password/page.tsx" isMerged="true"
"use client"

import type React from "react"
import { useState } from "react"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Label } from "@/components/ui/label"
import { createClient } from "@/lib/supabase/client"
import Link from "next/link"
import { ArrowLeft, Mail } from "lucide-react"

export default function ForgotPasswordPage() {
  const [email, setEmail] = useState("")
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [success, setSuccess] = useState(false)

const supabase = createClient()

const handleResetRequest = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)
    setError("")
    setSuccess(false)

const redirectUrl = `${window.location.origin}/auth/reset-password`

const { error: resetError } = await supabase.auth.resetPasswordForEmail(email, {
      redirectTo: redirectUrl,
    })

setLoading(false)

if (resetError) {
      setError(resetError.message)
    } else {
      setSuccess(true)
    }
  }

if (success) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-black p-4">
        <Card className="w-full max-w-md">
          <CardHeader>
            <div className="flex justify-center mb-4">
              <div className="w-12 h-12 bg-green-100 dark:bg-green-900 rounded-full flex items-center justify-center">
                <Mail className="w-6 h-6 text-green-600 dark:text-green-400" />
              </div>
            </div>
            <CardTitle className="text-center">Check Your Email</CardTitle>
            <CardDescription className="text-center">
              We've sent a password reset link to <strong>{email}</strong>
            </CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-4">
              <p className="text-sm text-muted-foreground text-center">
                Click the link in the email to reset your password. If you don't see it, check your spam folder.
              </p>
              <Button asChild className="w-full">
                <Link href="/auth/login">
                  <ArrowLeft className="w-4 h-4 mr-2" />
                  Back to Login
                </Link>
              </Button>
            </div>
          </CardContent>
        </Card>
      </div>
    )
  }

return (
    <div className="min-h-screen flex items-center justify-center bg-black p-4">
      <Card className="w-full max-w-md">
        <CardHeader>
          <CardTitle>Reset Your Password</CardTitle>
          <CardDescription>Enter your email address and we'll send you a reset link</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleResetRequest} className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="email">Email Address</Label>
              <Input
                id="email"
                type="email"
                placeholder="you@example.com"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
                required
              />
            </div>
            {error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}
            <Button type="submit" className="w-full" disabled={loading}>
              {loading ? "Sending..." : "Send Reset Link"}
            </Button>
          </form>
          <div className="mt-4 text-center text-sm">
            <Link href="/auth/login" className="text-muted-foreground hover:text-primary inline-flex items-center">
              <ArrowLeft className="w-4 h-4 mr-1" />
              Back to Login
            </Link>
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/auth/reset-password/page.tsx" isMerged="true"
"use client"

import type React from "react"
import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
import { Label } from "@/components/ui/label"
import { createClient } from "@/lib/supabase/client"
import { useRouter } from "next/navigation"
import Link from "next/link"
import { Eye, EyeOff, CheckCircle2 } from "lucide-react"
import { validatePassword, type PasswordValidation } from "@/lib/password-security"

export default function ResetPasswordPage() {
  const [password, setPassword] = useState("")
  const [confirmPassword, setConfirmPassword] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [showConfirmPassword, setShowConfirmPassword] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [success, setSuccess] = useState(false)
  const [validation, setValidation] = useState<PasswordValidation | null>(null)
  const [hasValidToken, setHasValidToken] = useState(false)
  const router = useRouter()

const supabase = createClient()

useEffect(() => {
    // Check if user came from password reset link
    supabase.auth.getSession().then(({ data: { session } }) => {
      if (session) {
        setHasValidToken(true)
      } else {
        setError("Invalid or expired reset link. Please request a new one.")
      }
    })
  }, [supabase.auth])

useEffect(() => {
    if (password) {
      setValidation(validatePassword(password))
    } else {
      setValidation(null)
    }
  }, [password])

const handleResetPassword = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)
    setError("")

if (!validation || !validation.isValid) {
      setError("Please ensure your password meets all security requirements")
      setLoading(false)
      return
    }

if (password !== confirmPassword) {
      setError("Passwords do not match")
      setLoading(false)
      return
    }

try {
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (!user) {
        setError("Session expired. Please request a new reset link.")
        setLoading(false)
        return
      }

const { data: profile } = await supabase
        .from("profiles")
        .select("encrypted_wallet, has_builtin_wallet")
        .eq("id", user.id)
        .single()

// Note: For password reset, we cannot decrypt the old wallet because we don't have the old password
      // The wallet will need to be recovered using the recovery phrase
      // We'll clear the wallet and let the user recover it
      if (profile?.encrypted_wallet && profile?.has_builtin_wallet) {
        // Clear the old encrypted wallet since we can't decrypt it without old password
        await supabase
          .from("profiles")
          .update({
            encrypted_wallet: null,
            has_builtin_wallet: false,
          })
          .eq("id", user.id)

// Clear localStorage
        localStorage.removeItem("linkficrypto_wallet")
        localStorage.removeItem("linkficrypto_wallet_address")
      }

// Update password in Supabase Auth
      const { error: updateError } = await supabase.auth.updateUser({
        password: password,
      })

if (updateError) {
        setError(updateError.message)
        setLoading(false)
        return
      }

sessionStorage.removeItem("linkficrypto_wallet_session")
      sessionStorage.removeItem("linkficrypto_wallet_unlocked")

setSuccess(true)
      setTimeout(() => {
        router.push("/auth/login?message=password-reset-complete")
      }, 3000)
    } catch (err: any) {
      setError(err.message || "Failed to reset password. Please try again.")
      setLoading(false)
    }
  }

if (!hasValidToken && error) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-black p-4">
        <Card className="w-full max-w-md">
          <CardHeader>
            <CardTitle>Invalid Reset Link</CardTitle>
            <CardDescription>This password reset link is invalid or has expired</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-4">
              <p className="text-sm text-muted-foreground">{error}</p>
              <Button asChild className="w-full">
                <Link href="/auth/forgot-password">Request New Reset Link</Link>
              </Button>
            </div>
          </CardContent>
        </Card>
      </div>
    )
  }

if (success) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-black p-4">
        <Card className="w-full max-w-md">
          <CardHeader>
            <div className="flex justify-center mb-4">
              <div className="w-12 h-12 bg-green-100 dark:bg-green-900 rounded-full flex items-center justify-center">
                <CheckCircle2 className="w-6 h-6 text-green-600 dark:text-green-400" />
              </div>
            </div>
            <CardTitle className="text-center">Password Reset Successful</CardTitle>
            <CardDescription className="text-center">Your password has been updated successfully</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-4">
              {/* Warning about wallet recovery */}
              <div className="p-3 bg-orange-50 dark:bg-orange-950 border border-orange-200 dark:border-orange-800 rounded-lg">
                <p className="text-sm text-orange-900 dark:text-orange-100 font-medium">
                  Important: Wallet Recovery Required
                </p>
                <p className="text-xs text-orange-700 dark:text-orange-300 mt-1">
                  You'll need to import your wallet using your recovery phrase after logging in with your new password.
                </p>
              </div>
              <p className="text-sm text-muted-foreground text-center">Redirecting to login page...</p>
              <Button asChild className="w-full">
                <Link href="/auth/login">Go to Login</Link>
              </Button>
            </div>
          </CardContent>
        </Card>
      </div>
    )
  }

return (
    <div className="min-h-screen flex items-center justify-center bg-black p-4">
      <Card className="w-full max-w-md">
        <CardHeader>
          <CardTitle>Create New Password</CardTitle>
          <CardDescription>Choose a strong password for your account</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleResetPassword} className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="password">New Password</Label>
              <div className="relative">
                <Input
                  id="password"
                  type={showPassword ? "text" : "password"}
                  value={password}
                  onChange={(e) => setPassword(e.target.value)}
                  required
                />
                <button
                  type="button"
                  onClick={() => setShowPassword(!showPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                </button>
              </div>
            </div>

{validation && password && (
              <div className="space-y-2 text-sm">
                <div className="flex items-center gap-2">
                  <div
                    className={`w-2 h-2 rounded-full ${validation.score >= 3 ? "bg-green-500" : validation.score >= 2 ? "bg-yellow-500" : "bg-red-500"}`}
                  />
                  <span className="font-medium">
                    Password Strength:{" "}
                    {validation.score >= 4
                      ? "Excellent"
                      : validation.score >= 3
                        ? "Strong"
                        : validation.score >= 2
                          ? "Fair"
                          : "Weak"}
                  </span>
                </div>
                <ul className="space-y-1 ml-4">
                  {validation.checks.map((check, i) => (
                    <li key={i} className={check.valid ? "text-green-600" : "text-muted-foreground"}>
                      {check.valid ? "✓" : "○"} {check.message}
                    </li>
                  ))}
                </ul>
              </div>
            )}

<div className="space-y-2">
              <Label htmlFor="confirmPassword">Confirm New Password</Label>
              <div className="relative">
                <Input
                  id="confirmPassword"
                  type={showConfirmPassword ? "text" : "password"}
                  value={confirmPassword}
                  onChange={(e) => setConfirmPassword(e.target.value)}
                  required
                />
                <button
                  type="button"
                  onClick={() => setShowConfirmPassword(!showConfirmPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showConfirmPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                </button>
              </div>
            </div>

{error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}

<Button
              type="submit"
              className="w-full"
              disabled={loading || !validation?.isValid || password !== confirmPassword}
            >
              {loading ? "Updating Password..." : "Reset Password"}
            </Button>
          </form>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/auth/sign-up/page.tsx" isMerged="true"
"use client"

export default function SignUpPage() {
  const [email, setEmail] = useState("")
  const [password, setPassword] = useState("")
  const [username, setUsername] = useState("")
  const [showPassword, setShowPassword] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState("")
  const [message, setMessage] = useState("")

const supabase = createClient()

const passwordStrength = validatePasswordStrength(password)

const passwordRequirements = [
    { label: "At least 8 characters", met: password.length >= 8 },
    { label: "Contains uppercase and lowercase", met: /[a-z]/.test(password) && /[A-Z]/.test(password) },
    { label: "Contains a number", met: /\d/.test(password) },
    { label: "Contains a special character", met: /[!@#$%^&*(),.?":{}|<>]/.test(password) },
  ]

const handleSignUp = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)
    setError("")
    setMessage("")

// Validate username format
    if (!/^[a-zA-Z0-9_]{3,20}$/.test(username)) {
      setError("Username must be 3-20 characters (letters, numbers, underscores only)")
      setLoading(false)
      return
    }

if (!passwordStrength.isSecure) {
      setError("Password does not meet security requirements. Please use a stronger password.")
      setLoading(false)
      return
    }

try {
      console.log("[v0] Generating new wallet for user...")
      const newWallet = generateWallet()

const encryptedWallet = await encryptWallet(newWallet, password)

const redirectUrl = process.env.NEXT_PUBLIC_DEV_SUPABASE_REDIRECT_URL || `${window.location.origin}/auth/callback`

const { data, error: signUpError } = await supabase.auth.signUp({
        email,
        password,
        options: {
          data: {
            username: username.toLowerCase(),
            wallet_address: newWallet.address,
            has_wallet: true,
          },
          emailRedirectTo: redirectUrl,
        },
      })

if (signUpError) {
        setError(signUpError.message)
        setLoading(false)
        return
      }

if (data.user) {
        localStorage.setItem("linkficrypto_wallet", encryptedWallet)
        localStorage.setItem("linkficrypto_wallet_address", newWallet.address)

try {
          await supabase.from("profiles").insert({
            id: data.user.id,
            username: username.toLowerCase(),
            wallet_address: newWallet.address,
            builtin_wallet_address: newWallet.address,
            encrypted_wallet: encryptedWallet,
            has_builtin_wallet: true,
          })
        } catch (profileError) {
          console.log("[v0] Profile will be created after email confirmation")
        }

setMessage("✓ Account created! Check your email to confirm your account and access your wallet.")
        setLoading(false)
      }
    } catch (err: any) {
      console.error("[v0] Signup error:", err)
      setError(err.message || "Failed to create account. Please try again.")
      setLoading(false)
    }
  }

return (
    <div className="min-h-screen flex items-center justify-center bg-black p-4">
      <Card className="w-full max-w-md">
        <CardHeader>
          <CardTitle>Create Account</CardTitle>
          <CardDescription>Join LinkFiCrypto - Your wallet is created automatically</CardDescription>
        </CardHeader>
        <CardContent>
          <form onSubmit={handleSignUp} className="space-y-4">
            <div className="space-y-2">
              <Label htmlFor="username">Username</Label>
              <div className="flex items-center">
                <span className="text-muted-foreground mr-1">@</span>
                <Input
                  id="username"
                  type="text"
                  placeholder="username"
                  value={username}
                  onChange={(e) => setUsername(e.target.value.toLowerCase())}
                  required
                />
              </div>
              <p className="text-xs text-muted-foreground">3-20 characters, letters, numbers, and underscores only</p>
            </div>

<div className="space-y-2">
              <Label htmlFor="email">Email</Label>
              <Input
                id="email"
                type="email"
                placeholder="you@example.com"
                value={email}
                onChange={(e) => setEmail(e.target.value)}
                required
              />
            </div>

<div className="space-y-2">
              <Label htmlFor="password">Password</Label>
              <div className="relative">
                <Input
                  id="password"
                  type={showPassword ? "text" : "password"}
                  placeholder="Create a strong password"
                  value={password}
                  onChange={(e) => setPassword(e.target.value)}
                  required
                  minLength={8}
                />
                <button
                  type="button"
                  onClick={() => setShowPassword(!showPassword)}
                  className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
                >
                  {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
                </button>
              </div>

{password && (
                <>
                  <div className="flex items-center gap-2">
                    <div className="flex-1 h-2 bg-muted rounded-full overflow-hidden">
                      <div
                        className={`h-full transition-all ${
                          passwordStrength.score <= 2
                            ? "bg-red-500"
                            : passwordStrength.score <= 3
                              ? "bg-orange-500"
                              : passwordStrength.score <= 4
                                ? "bg-yellow-500"
                                : "bg-green-500"
                        }`}
                        style={{ width: `${(passwordStrength.score / 5) * 100}%` }}
                      />
                    </div>
                    <span className={`text-xs font-medium ${passwordStrength.color}`}>{passwordStrength.label}</span>
                  </div>

<div className="space-y-1 mt-2">
                    {passwordRequirements.map((req, i) => (
                      <div key={i} className="flex items-center gap-2 text-xs">
                        {req.met ? (
                          <Check className="w-3 h-3 text-green-500" />
                        ) : (
                          <X className="w-3 h-3 text-muted-foreground" />
                        )}
                        <span className={req.met ? "text-green-600 dark:text-green-400" : "text-muted-foreground"}>
                          {req.label}
                        </span>
                      </div>
                    ))}
                  </div>
                </>
              )}
            </div>

<div className="p-3 bg-primary/5 border border-primary/20 rounded-lg">
              <div className="flex gap-2">
                <AlertCircle className="w-4 h-4 text-primary flex-shrink-0 mt-0.5" />
                <div className="text-xs text-muted-foreground">
                  <p className="font-medium text-foreground mb-1">Automatic Wallet Creation</p>
                  <p>
                    A secure crypto wallet will be automatically created for you. Your password encrypts your wallet -
                    never share it!
                  </p>
                </div>
              </div>
            </div>

{error && <div className="text-sm text-red-500 bg-red-50 dark:bg-red-950 p-3 rounded">{error}</div>}
            {message && (
              <div className="text-sm text-green-600 bg-green-50 dark:bg-green-950 p-3 rounded">{message}</div>
            )}

<Button type="submit" className="w-full" disabled={loading}>
              {loading ? "Creating account..." : "Create Account & Wallet"}
            </Button>
          </form>

<div className="mt-4 text-center text-sm">
            Already have an account?{" "}
            <Link href="/auth/login" className="text-primary hover:underline">
              Sign in
            </Link>
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/send-interface.tsx" isMerged="true"
"use client"

import { useState, useRef, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Send, AlertCircle, QrCode, X, BookUser, Zap, ArrowUpDown } from "lucide-react"
import { AddressBookModal } from "@/components/address-book-modal"
import { TransactionConfirmationModal } from "@/components/transaction-confirmation-modal"
import { TransactionStatusToast } from "@/components/transaction-status-toast"
import { updateLastUsed } from "@/lib/address-book"
import { createClient } from "@/lib/supabase/client"
import { RiskDisclaimer } from "@/components/risk-disclaimer"
import { getTokenPrices } from "@/lib/token-prices"
import {
  calculateGasFees,
  recordCommission,
  sendCommissionPayment,
  type GasFeeCalculation,
  type GasFeeSpeed,
} from "@/lib/gas-fee-calculator"
import { BuiltInWalletProvider } from "@/lib/builtin-wallet-provider"
import { Wallet } from "ethers"

interface SendInterfaceProps {
  address: string
  balance: string
  token: string
  provider?: any
  unlockedWalletData?: any
}

export function SendInterface({ address, balance, token, provider, unlockedWalletData }: SendInterfaceProps) {
  console.log("[v0 SEND] SendInterface mounted with:", {
    address: address?.slice(0, 10),
    balance,
    token,
    hasProvider: !!provider,
    hasUnlockedWallet: !!unlockedWalletData,
  })

const [recipient, setRecipient] = useState("")
  const [amount, setAmount] = useState("")
  const [sending, setSending] = useState(false)
  const [showScanner, setShowScanner] = useState(false)
  const [scanError, setScanError] = useState("")
  const [showAddressBook, setShowAddressBook] = useState(false)
  const [gasFees, setGasFees] = useState<GasFeeCalculation | null>(null)
  const [selectedGasSpeed, setSelectedGasSpeed] = useState<GasFeeSpeed>("normal")
  const [loadingGasFees, setLoadingGasFees] = useState(false)
  const [showConfirmation, setShowConfirmation] = useState(false)
  const [txStatus, setTxStatus] = useState<"pending" | "success" | "error" | null>(null)
  const [txMessage, setTxMessage] = useState<string>()
  const [txHash, setTxHash] = useState<string>()
  const [usdPrice, setUsdPrice] = useState<number>(0)
  const videoRef = useRef<HTMLVideoElement>(null)
  const streamRef = useRef<MediaStream | null>(null)

const supabase = createClient()

fetchPrice()
    const interval = setInterval(fetchPrice, 15000)
    return () => clearInterval(interval)
  }, [token])

const loadGasFees = async () => {
    if (!amount) return

setLoadingGasFees(true)
    try {
      console.log("[v0 SEND] Checking for wallet provider...")
      console.log("[v0 SEND] Provider prop exists:", !!provider)
      console.log("[v0 SEND] builtInWalletProvider exists:", !!(window as any).builtInWalletProvider)
      console.log("[v0 SEND] window.ethereum exists:", !!window.ethereum)
      console.log("[v0 SEND] unlockedWalletData exists:", !!unlockedWalletData)

let walletProvider = provider || (window as any).builtInWalletProvider || window.ethereum

// Try to get wallet from session storage if not available
      if (!walletProvider && !unlockedWalletData) {
        try {
          const storedWallet = sessionStorage.getItem("unlockedWallet") || 
                              sessionStorage.getItem("linkficrypto_wallet_session")
          if (storedWallet) {
            const parsed = JSON.parse(storedWallet)
            const pk = parsed.privateKey
            if (pk) {
              const wallet = new Wallet(pk)
              walletProvider = new BuiltInWalletProvider(wallet, undefined, 1)
              ;(window as any).builtInWalletProvider = walletProvider
              console.log("[v0 SEND] Reconstructed provider from session storage")
            }
          }
        } catch (e) {
          console.error("[v0 SEND] Failed to restore wallet from session:", e)
        }
      }

if (!walletProvider && unlockedWalletData) {
        const wallet = new Wallet(unlockedWalletData.privateKey)
        walletProvider = new BuiltInWalletProvider(
          wallet,
        process.env.NEXT_PUBLIC_MAINNET_RPC_URL || "https://eth.llamarpc.com",
      )
      console.log("[v0 SEND] Reconstructed provider from unlocked wallet data")
    }

if (!walletProvider) {
        console.error("[v0 SEND] No provider available for gas calculation")
        setTxStatus("error")
        setTxMessage("Unable to access wallet. Please sign in with your password again.")
        setLoadingGasFees(false)
        return
      }

console.log("[v0 SEND] Using provider for gas calculation")
      const fees = await calculateGasFees(walletProvider, token)
      setGasFees(fees)
      setSelectedGasSpeed(fees.selected)
      console.log(`[v0] Gas fees loaded for ${token}:`, fees)
    } catch (error) {
      console.error("[v0] Error loading gas fees:", error)
      setTxStatus("error")
      setTxMessage("Unable to calculate network fees. Please try again.")
    } finally {
      setLoadingGasFees(false)
    }
  }

const handleReviewTransaction = async () => {
    if (!recipient || !amount) return

if (!gasFees) {
      setTxStatus("error")
      setTxMessage("Please load network fees before sending")
      return
    }

if (!selectedGasSpeed) {
      setTxStatus("error")
      setTxMessage("Please select a network fee option")
      return
    }

if (!recipient.match(/^0x[a-fA-F0-9]{40}$/)) {
      setTxStatus("error")
      setTxMessage("Invalid recipient address. Please check and try again.")
      return
    }

if (Number.parseFloat(amount) > Number.parseFloat(balance)) {
      setTxStatus("error")
      setTxMessage("Insufficient balance for this transaction.")
      return
    }

setShowConfirmation(true)
  }

const handleSend = async () => {
    setShowConfirmation(false)
    console.log("[v0 COMMISSION DEBUG] SendInterface handleSend started...")
    console.log("[v0 SEND] Checking wallet access...")
    console.log("[v0 SEND] provider exists:", !!provider)
    console.log("[v0 SEND] window.ethereum exists:", !!window.ethereum)
    console.log("[v0 SEND] builtInWalletProvider exists:", !!(window as any).builtInWalletProvider)
    console.log("[v0 SEND] unlockedWalletData exists:", !!unlockedWalletData)

let walletProvider = provider || (window as any).builtInWalletProvider || window.ethereum

// Try to get wallet from session storage if not available
    if (!walletProvider && !unlockedWalletData) {
      try {
        const storedWallet = sessionStorage.getItem("unlockedWallet") || 
                            sessionStorage.getItem("linkficrypto_wallet_session")
        if (storedWallet) {
          const parsed = JSON.parse(storedWallet)
          const pk = parsed.privateKey
          if (pk) {
            const wallet = new Wallet(pk)
            walletProvider = new BuiltInWalletProvider(wallet, undefined, 1)
            ;(window as any).builtInWalletProvider = walletProvider
            console.log("[v0 SEND] Reconstructed provider from session storage for send")
          }
        }
      } catch (e) {
        console.error("[v0 SEND] Failed to restore wallet from session:", e)
      }
    }

if (!walletProvider && unlockedWalletData) {
      const wallet = new Wallet(unlockedWalletData.privateKey)
      walletProvider = new BuiltInWalletProvider(
        wallet,
        process.env.NEXT_PUBLIC_MAINNET_RPC_URL || "https://eth.llamarpc.com",
      )
      console.log("[v0 SEND] Reconstructed provider from unlocked wallet data")
    }

if (!walletProvider) {
      setTxStatus("error")
      setTxMessage("Failed to access your wallet. Please refresh the page and sign in again.")
      setSending(false)
      return
    }

setSending(true)
    setTxStatus("pending")
    setTxMessage("Waiting for wallet confirmation...")

try {
      console.log("[v0 SEND] Requesting accounts from wallet...")
      const accounts = await walletProvider.request({
        method: "eth_requestAccounts",
      })

console.log("[v0 SEND] Got accounts:", accounts.length)

const amountInWei = (Number.parseFloat(amount) * 1e18).toString(16)

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)

if (!selectedGasOption) {
        throw new Error("Selected gas option not found")
      }

if (!recipient || recipient.length !== 42 || !recipient.startsWith("0x")) {
        throw new Error("Invalid recipient address format")
      }

console.log("[v0 SEND] Checking balance...")
      const balanceWei = BigInt(
        await walletProvider.request({
          method: "eth_getBalance",
          params: [accounts[0], "latest"],
        }),
      )
      const requiredWei = BigInt(`0x${amountInWei}`) + BigInt(selectedGasOption.totalCostWei)

console.log("[v0 SEND] Balance:", balanceWei.toString(), "Required:", requiredWei.toString())

if (balanceWei < requiredWei) {
        throw new Error("insufficient funds for transfer and gas")
      }

setTxMessage("Sending transaction...")

const txParams = {
        from: accounts[0],
        to: recipient,
        value: `0x${amountInWei}`,
        maxFeePerGas: `0x${selectedGasOption.maxFeePerGas.toString(16)}`,
        maxPriorityFeePerGas: `0x${selectedGasOption.maxPriorityFeePerGas.toString(16)}`,
        gas: `0x${selectedGasOption.gasLimit.toString(16)}`, // Added explicit gas limit
      }

console.log("[v0 SEND] Transaction params:", txParams)

// Add timeout to prevent hanging indefinitely
      const txPromise = walletProvider.request({
        method: "eth_sendTransaction",
        params: [txParams],
      })
      
      const timeoutPromise = new Promise<never>((_, reject) => {
        setTimeout(() => reject(new Error("Transaction timed out after 60 seconds")), 60000)
      })

const txHash = await Promise.race([txPromise, timeoutPromise])

setTxHash(txHash)
      console.log("[v0] Transaction sent, hash:", txHash)

const {
        data: { user },
      } = await supabase.auth.getUser()

await supabase.from("transactions").insert({
        user_id: user?.id || null,
        tx_hash: txHash,
        type: "send",
        from_address: address,
        to_address: recipient,
        amount: Number.parseFloat(amount),
        token: token,
        status: "confirmed",
        confirmed_at: new Date().toISOString(),
      })

const commissionAmount = Number.parseFloat(selectedGasOption.commission)

let commissionTxHash: string | null = null

try {
        commissionTxHash = await sendCommissionPayment(walletProvider, address, commissionAmount)
        console.log("[v0 COMMISSION] Commission payment sent:", commissionTxHash)
      } catch (error) {
        console.error("[v0 COMMISSION ERROR] Failed to send commission payment:", error)
      }

try {
        const recordUserId = user?.id || "anonymous-" + Date.now()
        await recordCommission(
          supabase,
          recordUserId,
          txHash,
          Number.parseFloat(selectedGasOption.totalCost),
          commissionAmount,
          gasFees?.commissionRate || 0.875,
          token,
          commissionTxHash,
          address,
          recipient,
        )
        console.log("[v0 COMMISSION] Commission recorded in database successfully")
        console.log("[v0 COMMISSION] From:", address, "To:", recipient)
      } catch (error) {
        console.error("[v0 COMMISSION ERROR] Failed to record commission in database:", error)
      }

updateLastUsed(recipient)

setTxStatus("success")
      setTxMessage(`Successfully sent ${amount} ${token}!`)
      setRecipient("")
      setAmount("")
      setGasFees(null)
    } catch (error: any) {
      console.error("[v0] Transaction error:", error)
      let errorMessage = "Unable to send payment. Please try again."

if (error.message?.includes("insufficient funds")) {
        errorMessage = "Insufficient funds for this transaction including network fees."
      } else if (error.message?.includes("user rejected") || error.code === 4001) {
        errorMessage = "Transaction was cancelled."
      } else if (error.message?.includes("gas") || error.message?.includes("estimateGas")) {
        errorMessage = "Unable to estimate network fees. Please try again."
      } else if (error.message?.includes("revert") || error.code === "CALL_EXCEPTION") {
        errorMessage = `Unable to send payment: ${error.message || "transaction would fail"}`
      } else if (error.message) {
        errorMessage = `Unable to send payment: ${error.message}`
      }

setTxStatus("error")
      setTxMessage(errorMessage)
    } finally {
      setSending(false)
    }
  }

const startScanner = async () => {
    setShowScanner(true)
    setScanError("")

try {
      const stream = await navigator.mediaDevices.getUserMedia({
        video: { facingMode: "environment" },
      })
      streamRef.current = stream

if (videoRef.current) {
        videoRef.current.srcObject = stream
        videoRef.current.play()

scanQRCode()
      }
    } catch (error: any) {
      setScanError("Camera access denied. Please enable camera permissions.")
      console.error("Camera error:", error)
    }
  }

const stopScanner = () => {
    if (streamRef.current) {
      streamRef.current.getTracks().forEach((track) => track.stop())
      streamRef.current = null
    }
    setShowScanner(false)
    setScanError("")
  }

const scanQRCode = () => {
    if (!videoRef.current || !showScanner) return

const video = videoRef.current
    const canvas = document.createElement("canvas")
    const context = canvas.getContext("2d")

if (!context) return

canvas.width = video.videoWidth
    canvas.height = video.videoHeight

const scan = () => {
      if (!showScanner || !videoRef.current) return

context.drawImage(video, 0, 0, canvas.width, canvas.height)
      const imageData = context.getImageData(0, 0, canvas.width, canvas.height)

try {
        // This is a placeholder - in production use jsQR or similar library
        // const code = jsQR(imageData.data, imageData.width, imageData.height)
        // if (code && code.data.startsWith('0x')) {
        //   setRecipient(code.data)
        //   stopScanner()
        //   return
        // }
      } catch (error) {
        console.error("QR scan error:", error)
      }

requestAnimationFrame(scan)
    }

scan()
  }

const handleManualQRInput = () => {
    const address = prompt("Enter the Ethereum address from the QR code:")
    if (address && address.startsWith("0x")) {
      setRecipient(address)
      stopScanner()
    }
  }

const handleSelectFromAddressBook = (address: string) => {
    setRecipient(address)
    setShowAddressBook(false)
  }

const setMaxAmount = () => {
    setAmount(balance)
  }

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)

const usdValue = amount ? (Number.parseFloat(amount) * usdPrice).toFixed(2) : "0.00"

return (
    <div className="max-w-lg mx-auto">
      <TransactionStatusToast
        status={txStatus}
        message={txMessage}
        txHash={txHash}
        onClose={() => {
          setTxStatus(null)
          setTxMessage(undefined)
          setTxHash(undefined)
        }}
      />

<Card className="p-6 border-border">
        <div className="flex items-center gap-3 mb-6">
          <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
            <Send className="w-5 h-5 text-primary" />
          </div>
          <h2 className="text-2xl font-bold text-foreground">Send {token}</h2>
        </div>

<div className="space-y-4">
          <div className="space-y-2">
            <label className="text-sm font-medium text-foreground">Recipient Address</label>
            <div className="flex gap-2">
              <Input
                placeholder="0x..."
                value={recipient}
                onChange={(e) => setRecipient(e.target.value)}
                className="font-mono flex-1 h-12"
              />
              <Button
                type="button"
                variant="outline"
                size="icon"
                onClick={() => setShowAddressBook(true)}
                className="flex-shrink-0 bg-transparent h-12 w-12"
                title="Address Book"
              >
                <BookUser className="w-5 h-5" />
              </Button>
              <Button
                type="button"
                variant="outline"
                size="icon"
                onClick={startScanner}
                className="flex-shrink-0 bg-transparent h-12 w-12"
                title="Scan QR Code"
              >
                <QrCode className="w-5 h-5" />
              </Button>
            </div>
          </div>

<div className="space-y-2">
            <div className="flex items-center justify-between">
              <label className="text-sm font-medium text-foreground">Amount</label>
              <button onClick={setMaxAmount} className="text-sm text-primary hover:underline font-medium">
                Use Max
              </button>
            </div>
            <div className="relative">
              <Input
                type="number"
                placeholder="0.0"
                value={amount}
                onChange={(e) => {
                  setAmount(e.target.value)
                  setGasFees(null)
                }}
                onBlur={loadGasFees}
                className="text-2xl h-16 pr-20 font-bold"
              />
              <div className="absolute right-4 top-1/2 -translate-y-1/2">
                <span className="text-lg font-semibold text-muted-foreground">{token}</span>
              </div>
            </div>
            {amount && Number.parseFloat(amount) > 0 && (
              <div className="flex items-center justify-center py-2">
                <div className="inline-flex items-center gap-2 px-4 py-2 rounded-full bg-muted border border-border">
                  <ArrowUpDown className="w-4 h-4 text-muted-foreground" />
                  <span className="text-sm font-semibold text-foreground">${usdValue}</span>
                </div>
              </div>
            )}
            <p className="text-sm text-muted-foreground">
              Available: {balance} {token}
            </p>
          </div>

{amount && (
            <div className="space-y-3">
              <div className="flex items-center justify-between">
                <label className="text-sm font-medium text-foreground flex items-center gap-2">
                  <Zap className="w-4 h-4 text-primary" />
                  Network Speed
                  {token !== "ETH" && <span className="text-xs text-muted-foreground">(paid in ETH)</span>}
                </label>
                {!gasFees && (
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={loadGasFees}
                    disabled={loadingGasFees}
                    className="h-8 text-xs bg-transparent"
                  >
                    {loadingGasFees ? "Loading..." : "Load Fees"}
                  </Button>
                )}
              </div>

{gasFees && (
                <div className="space-y-2">
                  {gasFees.options.map((option) => (
                    <button
                      key={option.speed}
                      onClick={() => setSelectedGasSpeed(option.speed)}
                      className={`w-full p-4 rounded-xl border-2 transition-all text-left ${
                        selectedGasSpeed === option.speed
                          ? "border-primary bg-primary/5 shadow-sm ring-2 ring-primary/20"
                          : "border-border hover:border-primary/50"
                      }`}
                    >
                      <div className="flex items-center justify-between mb-2">
                        <div className="flex items-center gap-3">
                          <span className="text-2xl">{option.icon}</span>
                          <div>
                            <div className="font-semibold">{option.label}</div>
                            <div className="text-xs text-muted-foreground">{option.estimatedTime}</div>
                          </div>
                        </div>
                        <div className="text-right">
                          <div className="font-bold">${option.totalCostUsd}</div>
                          <div className="text-xs text-muted-foreground">{option.totalCostEth} ETH</div>
                        </div>
                      </div>
                      <p className="text-xs text-muted-foreground pl-11">{option.description}</p>
                    </button>
                  ))}
                  <div className="p-2 bg-muted/50 rounded-lg">
                    <p className="text-xs text-muted-foreground text-center">
                      Platform fee: {gasFees.commissionRate}% • ETH: ${gasFees.ethPriceUsd.toFixed(2)}
                    </p>
                  </div>
                </div>
              )}
            </div>
          )}

<div className="p-3 rounded-lg bg-amber-500/10 border border-amber-500/20">
            <div className="flex items-start gap-2">
              <AlertCircle className="w-4 h-4 text-amber-600 mt-0.5 flex-shrink-0" />
              <p className="text-sm text-foreground">Transactions cannot be reversed. Double-check all details.</p>
            </div>
          </div>

<Button
            onClick={handleReviewTransaction}
            size="lg"
            className="w-full h-14 text-lg font-semibold"
            disabled={!recipient || !amount || Number.parseFloat(amount) <= 0 || sending || !gasFees}
          >
            {sending ? "Sending..." : "Review & Send"}
          </Button>
        </div>
      </Card>

{selectedGasOption && (
        <TransactionConfirmationModal
          isOpen={showConfirmation}
          onClose={() => setShowConfirmation(false)}
          onConfirm={handleSend}
          recipient={recipient}
          amount={amount}
          token={token}
          gasFee={selectedGasOption.totalCostEth}
          gasFeeUsd={selectedGasOption.totalCostUsd}
          totalCost={
            token === "ETH"
              ? `${(Number.parseFloat(amount) + Number.parseFloat(selectedGasOption.totalCostEth)).toFixed(6)} ETH`
              : `${amount} ${token} + ${selectedGasOption.totalCostEth} ETH`
          }
          totalCostUsd={(
            Number.parseFloat(amount) * gasFees!.ethPriceUsd +
            Number.parseFloat(selectedGasOption.totalCostUsd)
          ).toFixed(2)}
        />
      )}

{showAddressBook && (
        <AddressBookModal onClose={() => setShowAddressBook(false)} onSelectAddress={handleSelectFromAddressBook} />
      )}

{showScanner && (
        <div className="fixed inset-0 bg-black/90 flex items-center justify-center z-50 p-4">
          <div className="w-full max-w-md">
            <Card className="p-6 bg-card border-border">
              <div className="flex items-center justify-between mb-4">
                <h3 className="text-lg font-semibold text-foreground">Scan QR Code</h3>
                <Button variant="ghost" size="icon" onClick={stopScanner}>
                  <X className="w-5 h-5" />
                </Button>
              </div>

{scanError && (
                <div className="p-3 rounded-lg bg-destructive/10 border border-destructive/20 mb-4">
                  <p className="text-sm text-destructive">{scanError}</p>
                </div>
              )}

<div className="space-y-2">
                <p className="text-sm text-muted-foreground text-center">
                  Position the QR code within the frame to scan
                </p>
                <Button variant="outline" onClick={handleManualQRInput} className="w-full bg-transparent">
                  Enter Address Manually
                </Button>
              </div>
            </Card>
          </div>
        </div>
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/unified-send-interface.tsx" isMerged="true"
"use client"

import { useState, useRef, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { Send, AlertCircle, QrCode, X, BookUser, Zap, ArrowUpDown, UserCircle, Wallet } from "lucide-react"
import { AddressBookModal } from "@/components/address-book-modal"
import { TransactionConfirmationModal } from "@/components/transaction-confirmation-modal"
import { TransactionStatusToast } from "@/components/transaction-status-toast"
import { createClient } from "@/lib/supabase/client"
import { RiskDisclaimer } from "@/components/risk-disclaimer"
import { getTokenPrices, getTokenBalances } from "@/lib/token-prices"
import {
  calculateGasFees,
  sendCommissionPayment,
  recordCommission,
  type GasFeeCalculation,
  type GasFeeSpeed,
} from "@/lib/gas-fee-calculator"
import { ethers } from "ethers"

interface UserProfile {
  id: string
  username: string
  wallet_address: string | null
}

interface ConnectedWallet {
  address: string
  type: "metamask" | "walletconnect" | "builtin"
  name: string
}

interface UnifiedSendInterfaceProps {
  userWalletAddress: string
  activeProvider: any
  user: any
  profile: any
}

export function UnifiedSendInterface({ userWalletAddress, activeProvider, user, profile }: UnifiedSendInterfaceProps) {
  const [recipient, setRecipient] = useState("")
  const [amount, setAmount] = useState("")
  const [token, setToken] = useState("ETH")
  const [note, setNote] = useState("")
  const [sending, setSending] = useState(false)
  const [showScanner, setShowScanner] = useState(false)
  const [scanError, setScanError] = useState("")
  const [showAddressBook, setShowAddressBook] = useState(false)
  const [gasFees, setGasFees] = useState<GasFeeCalculation | null>(null)
  const [selectedGasSpeed, setSelectedGasSpeed] = useState<GasFeeSpeed>("normal")
  const [loadingGasFees, setLoadingGasFees] = useState(false)
  const [showConfirmation, setShowConfirmation] = useState(false)
  const [txStatus, setTxStatus] = useState<"pending" | "success" | "error" | null>(null)
  const [txMessage, setTxMessage] = useState<string>()
  const [txHash, setTxHash] = useState<string>()
  const [usdPrice, setUsdPrice] = useState<number>(0)
  const [sendMode, setSendMode] = useState<"address" | "username">("address")
  const [balance, setBalance] = useState<string>("0")

const videoRef = useRef<HTMLVideoElement>(null)
  const streamRef = useRef<MediaStream | null>(null)

const supabase = createClient()

useEffect(() => {
    console.log("[v0 SEND INTERFACE] Component mounted with props:", {
      userWalletAddress,
      hasActiveProvider: !!activeProvider,
      activeProviderType: activeProvider?.constructor?.name,
      userId: user?.id,
      profileUsername: profile?.username,
    })
  }, [])

useEffect(() => {
    console.log("[v0 COMPONENT] UnifiedSendInterface mounted")
    console.log("[v0 COMPONENT] Props:", {
      userWalletAddress,
      activeProvider: !!activeProvider,
      user: !!user,
      profile: !!profile,
    })

// Clear any stale error states
    setTxStatus(null)
    setTxMessage("")
  }, [])

fetchPrice()
    const interval = setInterval(fetchPrice, 15000)
    return () => clearInterval(interval)
  }, [token])

useEffect(() => {
    if (sendMode !== "username") return

const searchUsers = async () => {
      if (recipient.length < 2 || !recipient.startsWith("@")) {
        setSearchResults([])
        return
      }

setIsSearching(true)
      const searchTerm = recipient.slice(1) // Remove @ symbol
      // Use the safe RPC that returns only non-sensitive columns (never encrypted_wallet)
      const { data, error } = await supabase.rpc("search_profiles", { search_term: searchTerm })

if (!error && data) {
        setSearchResults(data)
      }
      setIsSearching(false)
    }

const debounce = setTimeout(searchUsers, 300)
    return () => clearTimeout(debounce)
  }, [recipient, sendMode, supabase])

const fetchBalance = async () => {
    if (!userWalletAddress) {
      console.log("[v0 BALANCE] No wallet address provided")
      return
    }

try {
      console.log("[v0 BALANCE] Fetching balance using getTokenBalances for:", userWalletAddress)
      const balances = await getTokenBalances(userWalletAddress)
      console.log("[v0 BALANCE] Received token balances:", balances)

const ethBalance = balances.find((b) => b.symbol === "ETH")
      if (ethBalance) {
        console.log("[v0 BALANCE] ETH Balance:", ethBalance.balance, "ETH, Value:", ethBalance.value, "USD")
        setBalance(ethBalance.balance.toFixed(6))
      } else {
        console.log("[v0 BALANCE] No ETH balance found")
        setBalance("0")
      }
    } catch (error) {
      console.error("[v0 BALANCE] Error fetching balance:", error)
      setBalance("0")
    }
  }

useEffect(() => {
    console.log("[v0 BALANCE] useEffect triggered, userWalletAddress:", userWalletAddress)
    fetchBalance()
    const interval = setInterval(fetchBalance, 15000)
    return () => clearInterval(interval)
  }, [userWalletAddress])

useEffect(() => {
    if (txStatus === "error" && (amount || recipient)) {
      console.log("[v0 COMPONENT] User is trying again - clearing error")
      setTxStatus(null)
      setTxMessage("")
    }
  }, [amount, recipient, txStatus])

const [searchResults, setSearchResults] = useState<UserProfile[]>([])
  const [selectedUser, setSelectedUser] = useState<UserProfile | null>(null)
  const [isSearching, setIsSearching] = useState(false)

const handleSelectUser = (user: UserProfile) => {
    setSelectedUser(user)
    setRecipient(`@${user.username}`)
    setSearchResults([])
  }

const getRecipientAddress = (): string => {
    if (sendMode === "username") {
      return selectedUser?.wallet_address || ""
    }
    return recipient
  }

const loadGasFees = async () => {
    if (!amount) return

setLoadingGasFees(true)
    try {
      const fees = await calculateGasFees(activeProvider, token)
      setGasFees(fees)
      setSelectedGasSpeed(fees.selected)
      console.log(`[v0] Gas fees loaded for ${token}:`, fees)
    } catch (error) {
      console.error("[v0] Error loading gas fees:", error)
      setTxStatus("error")
      setTxMessage("Unable to calculate network fees. Please try again.")
    } finally {
      setLoadingGasFees(false)
    }
  }

const handleReviewTransaction = async () => {
    const recipientAddr = getRecipientAddress()

console.log("[v0 REVIEW] Starting review with:", {
      recipientAddr,
      amount,
      balance,
      token,
      gasFees,
      selectedGasSpeed,
    })

if (!recipientAddr || !amount) return

if (!gasFees) {
      setTxStatus("error")
      setTxMessage("Please load network fees before sending")
      return
    }

if (!selectedGasSpeed) {
      setTxStatus("error")
      setTxMessage("Please select a network fee option")
      return
    }

if (!recipientAddr.match(/^0x[a-fA-F0-9]{40}$/)) {
      setTxStatus("error")
      setTxMessage("Invalid recipient address. Please check and try again.")
      return
    }

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)
    const gasFeesInEth = selectedGasOption ? Number.parseFloat(selectedGasOption.totalCostEth) : 0

console.log("[v0 REVIEW] Balance check:", {
      balance,
      balanceFloat: Number.parseFloat(balance),
      balanceIsZero: Number.parseFloat(balance) === 0,
      gasFeesInEth,
    })

const balanceFloat = Number.parseFloat(balance) || 0

if (balanceFloat === 0) {
      console.log("[v0 REVIEW] Zero balance detected - blocking transaction")
      setTxStatus("error")
      setTxMessage("You need ETH in your wallet to pay for network fees. Please add ETH to your wallet first.")
      return
    }

if (token === "ETH") {
      const totalNeeded = Number.parseFloat(amount) + gasFeesInEth
      console.log("[v0 REVIEW] ETH send - checking if", totalNeeded, ">", balanceFloat)

if (totalNeeded > balanceFloat) {
        console.log("[v0 REVIEW] Insufficient ETH for transaction + gas")
        setTxStatus("error")
        setTxMessage(
          `Insufficient ETH. You need ${totalNeeded.toFixed(6)} ETH (${amount} + ${gasFeesInEth.toFixed(6)} gas fee) but only have ${balance} ETH.`,
        )
        return
      }
    } else {
      // For other tokens, just need enough ETH for gas
      console.log("[v0 REVIEW] Token send - checking if gas", gasFeesInEth, ">", balanceFloat)

if (gasFeesInEth > balanceFloat) {
        console.log("[v0 REVIEW] Insufficient ETH for gas fees")
        setTxStatus("error")
        setTxMessage(
          `Insufficient ETH for gas fees. You need ${gasFeesInEth.toFixed(6)} ETH for gas but only have ${balance} ETH.`,
        )
        return
      }
    }

console.log("[v0 REVIEW] All checks passed - showing confirmation")
    setShowConfirmation(true)
  }

const handleSend = async () => {
    console.log("[v0 SEND] handleSend called")
    if (!amount || !recipient) {
      console.log("[v0 SEND] Missing amount or recipient")
      return
    }

console.log("[v0 SEND] Starting transaction with:", { amount, recipient, token, selectedGasSpeed })

setSending(true)
    setShowConfirmation(false)
    setTxStatus("pending")
    setTxMessage("Preparing transaction...")

try {
      const recipientAddr = selectedUser?.wallet_address || recipient
      console.log("[v0 SEND] Recipient address:", recipientAddr)

if (!ethers.isAddress(recipientAddr)) {
        console.error("[v0 SEND] Invalid recipient address:", recipientAddr)
        throw new Error("Invalid recipient address")
      }

let provider = activeProvider || (window as any).builtInWalletProvider

// Try to restore from session storage if no provider
      if (!provider) {
        try {
          const storedWallet = sessionStorage.getItem("unlockedWallet") || 
                              sessionStorage.getItem("linkficrypto_wallet_session")
          if (storedWallet) {
            const parsed = JSON.parse(storedWallet)
            const pk = parsed.privateKey
            if (pk) {
              const wallet = new ethers.Wallet(pk)
              const { BuiltInWalletProvider } = await import("@/lib/builtin-wallet-provider")
              provider = new BuiltInWalletProvider(wallet, undefined, 1)
              ;(window as any).builtInWalletProvider = provider
              console.log("[v0 SEND] Restored provider from session storage")
            }
          }
        } catch (e) {
          console.error("[v0 SEND] Failed to restore wallet from session:", e)
        }
      }

if (!provider) {
        console.error("[v0 SEND] No provider found!")
        throw new Error("No wallet provider available. Please refresh and sign in again.")
      }

console.log(
        "[v0 SEND] Using provider:",
        provider === (window as any).builtInWalletProvider ? "Built-in Wallet" : "External Wallet",
      )

console.log("[v0 SEND] Requesting accounts...")
      const accounts = await provider.request({
        method: "eth_requestAccounts",
      })

console.log("[v0 SEND] Wallet accounts:", accounts)

const amountInWei = (Number.parseFloat(amount) * 1e18).toString(16)
      console.log("[v0 SEND] Amount in wei:", amountInWei, "from amount:", amount)

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)
      console.log("[v0 SEND] Selected gas option:", selectedGasOption)

if (!selectedGasOption) {
        console.error("[v0 SEND] No gas option found for speed:", selectedGasSpeed)
        throw new Error("Selected gas option not found")
      }

setTxMessage("Sending transaction...")

console.log("[v0 SEND] Sending transaction with params:", {
        from: accounts[0],
        to: recipientAddr,
        value: `0x${amountInWei}`,
        maxFeePerGas: `0x${selectedGasOption.maxFeePerGas.toString(16)}`,
        maxPriorityFeePerGas: `0x${selectedGasOption.maxPriorityFeePerGas.toString(16)}`,
      })

const txResponse = await provider.request({
        method: "eth_sendTransaction",
        params: [
          {
            from: accounts[0],
            to: recipientAddr,
            value: `0x${amountInWei}`,
            maxFeePerGas: `0x${selectedGasOption.maxFeePerGas.toString(16)}`,
            maxPriorityFeePerGas: `0x${selectedGasOption.maxPriorityFeePerGas.toString(16)}`,
          },
        ],
      })

console.log("[v0 SEND] Transaction response:", txResponse)

const ethersProvider = new ethers.BrowserProvider(provider)
      const receipt = await ethersProvider.waitForTransaction(txResponse as string)
      console.log("[v0 SEND] Transaction confirmed!", receipt)

console.log("[v0 SEND] Saving transaction to database...")
      await fetch("/api/transactions/save", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          txHash: txResponse,
          fromAddress: accounts[0],
          toAddress: recipientAddr,
          amount: amount,
          token: token || "ETH",
          gasFee: Number.parseFloat(selectedGasOption.totalCost),
          type: "send",
          status: "confirmed",
        }),
      })

console.log("[v0 SEND] Transaction saved to database")

// Send commission payment
      const commissionAmount = Number.parseFloat(selectedGasOption.commission)
      let commissionTxHash: string | null = null

try {
        commissionTxHash = await sendCommissionPayment(provider, accounts[0], commissionAmount)
        console.log("[v0 COMMISSION] Commission payment sent:", commissionTxHash)
      } catch (commError) {
        console.error("[v0 COMMISSION ERROR] Failed to send commission:", commError)
      }

// Record commission in database
      try {
        const recordUserId = user?.id || "anonymous-" + Date.now()
        await recordCommission(
          supabase,
          recordUserId,
          txResponse as string,
          Number.parseFloat(selectedGasOption.totalCost),
          commissionAmount,
          gasFees?.commissionRate || 1,
          token || "ETH",
          commissionTxHash,
          accounts[0],
          recipientAddr,
        )
        console.log("[v0 COMMISSION] Commission recorded in database")
      } catch (recordError) {
        console.error("[v0 COMMISSION ERROR] Failed to record commission:", recordError)
      }

setTxStatus("success")
      setTxMessage(`Successfully sent ${amount} ${token || "ETH"}!`)
      setRecipient("")
      setAmount("")
      setGasFees(null)
      setSelectedGasSpeed("normal")

window.dispatchEvent(new CustomEvent("transactionComplete"))
    } catch (error: any) {
      console.error("[v0 SEND] Transaction error:", error)
      console.error("[v0 SEND] Error details:", {
        message: error.message,
        code: error.code,
        stack: error.stack,
      })
      let errorMessage = "Unable to send payment. Please try again."

setTxStatus("error")
      setTxMessage(errorMessage)
    } finally {
      setSending(false)
    }
  }

const startScanner = async () => {
    setShowScanner(true)
    setScanError("")

try {
      const stream = await navigator.mediaDevices.getUserMedia({
        video: { facingMode: "environment" },
      })
      streamRef.current = stream

if (videoRef.current) {
        videoRef.current.srcObject = stream
        videoRef.current.play()
      }
    } catch (error: any) {
      setScanError("Camera access denied. Please enable camera permissions.")
      console.error("Camera error:", error)
    }
  }

const handleSelectFromAddressBook = (address: string) => {
    setRecipient(address)
    setShowAddressBook(false)
  }

const setMaxAmount = () => {
    setAmount(balance)
  }

const selectedGasOption = gasFees?.options.find((opt) => opt.speed === selectedGasSpeed)
  const usdValue = amount ? (Number.parseFloat(amount) * usdPrice).toFixed(2) : "0.00"
  const recipientAddr = getRecipientAddress()

<Card className="p-6 border-border">
        <div className="flex items-center gap-3 mb-6">
          <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
            <Send className="w-5 h-5 text-primary" />
          </div>
          <div>
            <h2 className="text-2xl font-bold text-foreground">Send {token}</h2>
            <p className="text-sm text-muted-foreground">Send to address or @username</p>
          </div>
        </div>

<Tabs value={sendMode} onValueChange={(v) => setSendMode(v as "address" | "username")} className="mb-4">
          <TabsList className="grid w-full grid-cols-2">
            <TabsTrigger value="address" className="flex items-center gap-2">
              <Wallet className="w-4 h-4" />
              Address
            </TabsTrigger>
            <TabsTrigger value="username" className="flex items-center gap-2">
              <UserCircle className="w-4 h-4" />
              Username
            </TabsTrigger>
          </TabsList>
        </Tabs>

<div className="space-y-4">
          <div className="space-y-2">
            <label className="text-sm font-medium text-foreground">
              {sendMode === "address" ? "Recipient Address" : "Recipient @username"}
            </label>
            <div className="flex gap-2">
              <div className="relative flex-1">
                <Input
                  placeholder={sendMode === "address" ? "0x..." : "@username"}
                  value={recipient}
                  onChange={(e) => {
                    setRecipient(e.target.value)
                    if (sendMode === "username") setSelectedUser(null)
                  }}
                  className={`font-mono h-12 ${sendMode === "username" ? "pr-10" : ""}`}
                />
                {sendMode === "username" && isSearching && (
                  <div className="absolute right-3 top-1/2 -translate-y-1/2">
                    <div className="w-4 h-4 border-2 border-primary border-t-transparent rounded-full animate-spin" />
                  </div>
                )}
                {sendMode === "username" && searchResults.length > 0 && (
                  <div className="absolute top-full left-0 right-0 mt-1 bg-card border border-border rounded-lg shadow-lg z-10 max-h-60 overflow-y-auto">
                    {searchResults.map((user) => (
                      <button
                        key={user.id}
                        onClick={() => handleSelectUser(user)}
                        className="w-full px-4 py-3 text-left hover:bg-muted transition-colors border-b border-border last:border-0"
                      >
                        <div className="font-semibold">@{user.username}</div>
                        {user.wallet_address && (
                          <div className="text-xs text-muted-foreground font-mono">
                            {user.wallet_address.slice(0, 10)}...
                          </div>
                        )}
                      </button>
                    ))}
                  </div>
                )}
              </div>
              {sendMode === "address" && (
                <>
                  <Button
                    type="button"
                    variant="outline"
                    size="icon"
                    onClick={() => setShowAddressBook(true)}
                    className="flex-shrink-0 bg-transparent h-12 w-12"
                    title="Address Book"
                  >
                    <BookUser className="w-5 h-5" />
                  </Button>
                  <Button
                    type="button"
                    variant="outline"
                    size="icon"
                    onClick={startScanner}
                    className="flex-shrink-0 bg-transparent h-12 w-12"
                    title="Scan QR Code"
                  >
                    <QrCode className="w-5 h-5" />
                  </Button>
                </>
              )}
            </div>
          </div>

{sendMode === "username" && (
            <div className="space-y-2">
              <label className="text-sm font-medium text-foreground">Note (Optional)</label>
              <Input
                placeholder="What's this for?"
                value={note}
                onChange={(e) => setNote(e.target.value)}
                className="h-12"
              />
            </div>
          )}

{gasFees && (
                <div className="space-y-2">
                  {gasFees.options.map((option) => (
                    <button
                      key={option.speed}
                      onClick={() => setSelectedGasSpeed(option.speed)}
                      className={`w-full p-4 rounded-xl border-2 transition-all text-left ${
                        selectedGasSpeed === option.speed
                          ? "border-primary bg-primary/5 shadow-sm ring-2 ring-primary/20"
                          : "border-border hover:border-primary/50"
                      }`}
                    >
                      <div className="flex items-center justify-between mb-2">
                        <div className="flex items-center gap-3">
                          <span className="text-2xl">{option.icon}</span>
                          <div>
                            <div className="font-semibold">{option.label}</div>
                            <div className="text-xs text-muted-foreground">{option.estimatedTime}</div>
                          </div>
                        </div>
                        <div className="text-right">
                          <div className="font-bold">${option.totalCostUsd}</div>
                          <div className="text-xs text-muted-foreground">{option.totalCostEth} ETH</div>
                        </div>
                      </div>
                      <p className="text-xs text-muted-foreground pl-11">{option.description}</p>
                    </button>
                  ))}
                  <div className="p-2 bg-muted/50 rounded-lg">
                    <p className="text-xs text-muted-foreground text-center">
                      Platform fee: {gasFees.commissionRate}% • ETH: ${gasFees.ethPriceUsd.toFixed(2)}
                    </p>
                  </div>
                </div>
              )}
            </div>
          )}

<Button
            onClick={handleReviewTransaction}
            size="lg"
            className="w-full h-14 text-lg font-semibold"
            disabled={!recipientAddr || !amount || Number.parseFloat(amount) <= 0 || sending || !gasFees}
          >
            {sending ? "Sending..." : "Review & Send"}
          </Button>
        </div>
      </Card>

{selectedGasOption && (
        <TransactionConfirmationModal
          isOpen={showConfirmation}
          onClose={() => setShowConfirmation(false)}
          onConfirm={handleSend}
          recipient={sendMode === "username" ? recipient : recipientAddr}
          amount={amount}
          token={token}
          gasFee={selectedGasOption.totalCostEth}
          gasFeeUsd={selectedGasOption.totalCostUsd}
          totalCost={
            token === "ETH"
              ? `${(Number.parseFloat(amount) + Number.parseFloat(selectedGasOption.totalCostEth)).toFixed(6)} ETH`
              : `${amount} ${token} + ${selectedGasOption.totalCostEth} ETH`
          }
          totalCostUsd={(
            Number.parseFloat(amount) * gasFees!.ethPriceUsd +
            Number.parseFloat(selectedGasOption.totalCostUsd)
          ).toFixed(2)}
        />
      )}

{showAddressBook && (
        <AddressBookModal onClose={() => setShowAddressBook(false)} onSelectAddress={handleSelectFromAddressBook} />
      )}

import { Card } from "@/components/ui/card"
import {
  Wallet,
  TrendingUp,
  TrendingDown,
  Copy,
  ExternalLink,
  Check,
  X,
  ChevronDown,
  RefreshCw,
  LogOut,
  Send,
  QrCode,
  Store,
  Coins,
  ArrowDownUp,
  ShoppingBag,
} from "lucide-react"
import { Button } from "@/components/ui/button"
import { useState, useEffect } from "react"
import type { JSX } from "react"
import { getTokenBalances, formatPrice, formatChange, type TokenBalance } from "@/lib/token-prices"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { PaymentRequest } from "@/components/payment-request"
import { PaymentLinkGenerator } from "@/components/payment-link-generator"
import { TokenManager } from "@/components/token-manager"
import { createClient } from "@/lib/supabase/client"
import { useRouter } from "next/navigation"
import { AddMoneyInterface } from "@/components/add-money-interface"
import { SwapInterface } from "@/components/swap-interface"
import { BuiltInWalletProvider } from "@/lib/builtin-wallet-provider"
import { SimpleTransactionList } from "@/components/simple-transaction-list"
import { PaymentSend } from "@/components/payment-send"

interface ConnectedWallet {
  address: string
  balance: string
  provider: string
  name: string
}

interface WalletDashboardProps {
  connectedWallets: ConnectedWallet[]
  activeWallet: ConnectedWallet
  onSwitchWallet: (wallet: ConnectedWallet) => void
  onDisconnectWallet: (address: string) => void
  activeProvider?: any
}

export function WalletDashboard({
  connectedWallets,
  activeWallet,
  onSwitchWallet,
  onDisconnectWallet,
  activeProvider,
}: WalletDashboardProps) {
  const [copied, setCopied] = useState(false)
  const [showWalletSelector, setShowWalletSelector] = useState(false)
  const [tokens, setTokens] = useState<TokenBalance[]>([])
  const [isLoadingTokens, setIsLoadingTokens] = useState(false)
  const [unlockedWalletData, setUnlockedWalletData] = useState<{
    address: string
    privateKey: string
  } | null>(null)
  const [portfolioValue, setPortfolioValue] = useState(0)
  const [portfolioChange, setPortfolioChange] = useState(0)
  // Live on-chain balance per connected account address (in ETH, as a string)
  const [accountBalances, setAccountBalances] = useState<Record<string, string>>({})
  const [user, setUser] = useState<any>(null)
  const [profile, setProfile] = useState<any>(null)
  const [activeTab, setActiveTab] = useState("send")
  const supabase = createClient()
  const router = useRouter()

useEffect(() => {
    const loadWalletSession = () => {
      if (typeof window === "undefined") return

try {
        // Check primary session storage
        const sessionData = sessionStorage.getItem("linkficrypto_wallet_session")
        if (sessionData) {
          const walletData = JSON.parse(sessionData)
          if (walletData.privateKey && walletData.address) {
            console.log("[v0] Wallet session loaded from linkficrypto_wallet_session")
            setUnlockedWalletData(walletData)
            return
          }
        }

// Check secondary session storage
        const unlockedData = sessionStorage.getItem("unlockedWallet")
        if (unlockedData) {
          const walletData = JSON.parse(unlockedData)
          if (walletData.privateKey && walletData.address) {
            console.log("[v0] Wallet session loaded from unlockedWallet")
            setUnlockedWalletData(walletData)
            return
          }
        }

// Check if provider has wallet data
        if ((window as any).builtInWalletProvider) {
          const provider = (window as any).builtInWalletProvider
          if (provider.wallet && provider.wallet.privateKey) {
            console.log("[v0] Wallet session loaded from built-in wallet provider")
            setUnlockedWalletData({
              address: provider.wallet.address,
              privateKey: provider.wallet.privateKey,
            })
            return
          }
        }

console.log("[v0] No wallet session found - wallet is locked")
      } catch (error) {
        console.error("[v0] Error loading wallet session:", error)
      }
    }

loadWalletSession()

// Poll for wallet session every 2 seconds to detect unlocking
    const interval = setInterval(loadWalletSession, 2000)
    return () => clearInterval(interval)
  }, [])

useEffect(() => {
    console.log("[v0 Portfolio] useEffect triggered, activeWallet:", activeWallet?.address)
    
    const fetchBalances = async () => {
      if (!activeWallet?.address) {
        console.log("[v0 Portfolio] No active wallet address, skipping balance fetch")
        return
      }
      
      console.log("[v0 Portfolio] Fetching balances for address:", activeWallet.address)
      const isInitialLoad = tokens.length === 0
      if (isInitialLoad) {
        setIsLoadingTokens(true)
      }

try {
        // Use server-side API route for reliable balance fetch
        console.log("[v0 Portfolio] Calling /api/balance...")
        const apiResponse = await fetch(`/api/balance?address=${activeWallet.address}`)
        const apiData = await apiResponse.json()
        console.log("[v0 Portfolio] API response:", JSON.stringify(apiData))
        
        let balanceEth = 0
        if (apiData.balanceEth) {
          balanceEth = parseFloat(apiData.balanceEth)
          console.log("[v0 Portfolio] Got balance from API:", balanceEth, "ETH")
        } else if (apiData.error) {
          console.log("[v0 Portfolio] API error:", apiData.error)
        }
        
        // Ethereum mainnet ETH - use real USD price from API
        const ethPrice = apiData.ethPrice || 0
        const change24h = apiData.change24h || 0
        const usdValue = apiData.usdValue ?? balanceEth * ethPrice
        
        console.log("[v0 Portfolio] Final:", balanceEth.toFixed(6), "ETH = $", usdValue.toFixed(2))
        
        const balances = [{
          symbol: "ETH",
          balance: balanceEth,
          price: ethPrice,
          value: usdValue,
          change24h,
        }]
        
        setTokens(balances)
        setPortfolioValue(usdValue)
        setPortfolioChange(change24h)
      } catch (error) {
        console.error("[v0 Portfolio] Error fetching balances:", error)
      } finally {
        setIsLoadingTokens(false)
        console.log("[v0 Portfolio] Finished loading balances")
      }
    }

fetchBalances()

const intervalId = setInterval(fetchBalances, 15000)

return () => clearInterval(intervalId)
  }, [activeWallet.address])

useEffect(() => {
    const checkUser = async () => {
      const {
        data: { user },
      } = await supabase.auth.getUser()

if (user) {
        setUser(user)

const { data: profileData } = await supabase.from("profiles").select("*").eq("id", user.id).single()

if (profileData) {
          setProfile(profileData)
        }
      }
    }

checkUser()
  }, [activeWallet.address])

// Fetch live on-chain balances for every connected account so the
  // account switcher shows the correct amount for each (not stale values)
  useEffect(() => {
    let cancelled = false

const fetchAllBalances = async () => {
      if (!connectedWallets || connectedWallets.length === 0) return

const results = await Promise.all(
        connectedWallets.map(async (wallet) => {
          try {
            const res = await fetch(`/api/balance?address=${wallet.address}`)
            const data = await res.json()
            const eth = data.balanceEth ? parseFloat(data.balanceEth).toFixed(4) : "0.0000"
            return [wallet.address.toLowerCase(), eth] as const
          } catch (err) {
            console.log("[v0 Portfolio] Failed to fetch balance for", wallet.address, err)
            return [wallet.address.toLowerCase(), "0.0000"] as const
          }
        }),
      )

if (!cancelled) {
        setAccountBalances((prev) => {
          const next = { ...prev }
          for (const [addr, eth] of results) {
            next[addr] = eth
          }
          return next
        })
      }
    }

fetchAllBalances()

return () => {
      cancelled = true
    }
  }, [connectedWallets])

useEffect(() => {
    const initializeProvider = async () => {
      if (activeWallet.provider === "builtin") {
        const walletSession =
          sessionStorage.getItem("linkficrypto_wallet_session") || sessionStorage.getItem("unlockedWallet")
        console.log("[v0] Checking for unlocked wallet in sessionStorage:", !!walletSession)

if (walletSession) {
          try {
            const walletData = JSON.parse(walletSession)

if (walletData.address.toLowerCase() !== activeWallet.address.toLowerCase()) {
              console.log(
                "[v0] Session wallet mismatch! Session:",
                walletData.address,
                "Expected:",
                activeWallet.address,
              )
              console.log("[v0] Clearing invalid session data...")
              sessionStorage.removeItem("linkficrypto_wallet_session")
              sessionStorage.removeItem("unlockedWallet")
              sessionStorage.removeItem("linkficrypto_wallet_unlocked")
              console.log("[v0] Cleared invalid session. User needs to sign in again.")
              return
            }

console.log("[v0] Session wallet matches database, initializing provider...")
            console.log("[v0] Wallet has privateKey:", !!walletData.privateKey)

setUnlockedWalletData(walletData)

const provider = new BuiltInWalletProvider()
            await provider.initialize(walletData.privateKey)
            ;(window as any).builtInWalletProvider = provider

if (!activeProvider) {
              console.log("[v0] Setting activeProvider from initialized built-in wallet")
            }

console.log("[v0] Built-in wallet provider initialized successfully")

console.log("[v0] Triggering initial transaction scan for built-in wallet...")
            try {
              const response = await fetch("/api/transactions/detect-received", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ walletAddress: walletData.address }),
              })
              const result = await response.json()
              console.log("[v0] Initial scan result:", result.savedCount || 0, "new transactions")
            } catch (error) {
              console.error("[v0] Initial scan error:", error)
            }
          } catch (error) {
            console.error("[v0] Error initializing provider:", error)
          }
        } else {
          console.log("[v0] No unlocked wallet found in sessionStorage")
        }
      }
    }

initializeProvider()
  }, [activeWallet.provider, activeWallet.address])

const handleSignOutAll = () => {
    connectedWallets.forEach((wallet) => {
      onDisconnectWallet(wallet.address)
    })
  }

const getWalletLogo = (provider: string) => {
    const logos: Record<string, JSX.Element> = {
      metamask: (
        <div className="w-full h-full flex items-center justify-center p-2">
          <svg viewBox="0 0 318.6 318.6" className="w-full h-full">
            <polygon fill="#E17726" points="274.1,35.5 174.6,109.4 193,65.8" />
            <polygon fill="#E27625" points="44.4,35.5 143.1,110.1 125.6,65.8" />
            <polygon fill="#E27625" points="238.3,206.8 211.8,247.4 268.5,263 284.8,207.7" />
            <polygon fill="#E27625" points="33.9,207.7 50.1,263 106.8,247.4 80.3,206.8" />
            <polygon fill="#E27625" points="103.6,138.2 87.8,162.1 144.1,164.6 142.1,104.1" />
            <polygon fill="#E27625" points="214.9,138.2 175.9,103.4 174.6,164.6 230.8,162.1" />
            <polygon fill="#E27625" points="106.8,247.4 140.6,230.9 111.4,208.1" />
            <polygon fill="#E27625" points="177.9,230.9 211.8,247.4 207.1,208.1" />
            <polygon fill="#D5BFB2" points="211.8,247.4 177.9,230.9 180.6,253 180.3,262.3" />
            <polygon fill="#D5BFB2" points="106.8,247.4 138.3,262.3 138.1,253 140.6,230.9" />
            <polygon fill="#233447" points="138.8,193.5 110.6,185.2 130.5,176.1" />
            <polygon fill="#233447" points="179.7,193.5 188,176.1 208,185.2" />
            <polygon fill="#CC6228" points="106.8,247.4 111.6,206.8 80.3,207.7" />
            <polygon fill="#CC6228" points="207,206.8 211.8,247.4 238.3,207.7" />
            <polygon fill="#CC6228" points="230.8,162.1 174.6,164.6 179.8,193.5 188.1,176.1 208.1,185.2" />
            <polygon fill="#CC6228" points="110.6,185.2 130.6,176.1 138.8,193.5 144.1,164.6 87.8,162.1" />
            <polygon fill="#E27525" points="87.8,162.1 111.4,208.1 110.6,185.2" />
            <polygon fill="#E27525" points="208.1,185.2 207.1,208.1 230.8,162.1" />
            <polygon fill="#E27525" points="144.1,164.6 138.8,193.5 145.4,227.6 146.9,182.7" />
            <polygon fill="#E27525" points="174.6,164.6 171.9,182.6 173.1,227.6 179.8,193.5" />
            <polygon fill="#F5841F" points="179.8,193.5 173.1,227.6 177.9,230.9 207.1,208.1 208.1,185.2" />
            <polygon fill="#F5841F" points="110.6,185.2 111.4,208.1 140.6,230.9 145.4,227.6 138.8,193.5" />
            <polygon
              fill="#C0AC9D"
              points="180.3,262.3 180.6,253 178.1,250.8 140.4,250.8 138.1,253 138.3,262.3 106.8,247.4 117.8,256.4 140.1,271.9 178.4,271.9 200.8,256.4 211.8,247.4"
            />
            <polygon
              fill="#161616"
              points="177.9,230.9 173.1,227.6 145.4,227.6 140.6,230.9 138.1,253 140.4,250.8 178.1,250.8 180.6,253"
            />
            <polygon
              fill="#763E1A"
              points="278.3,114.2 286.8,73.4 274.1,35.5 177.9,106.9 214.9,138.2 267.2,153.5 278.8,140 273.8,136.4 281.8,129.1 275.6,124.3 283.6,118.2"
            />
            <polygon
              fill="#763E1A"
              points="31.8,73.4 40.3,114.2 34.9,118.2 42.9,124.3 36.8,129.1 44.8,136.4 39.8,140 51.3,153.5 103.6,138.2 140.6,106.9 44.4,35.5"
            />
            <polygon fill="#F5841F" points="267.2,153.5 214.9,138.2 230.8,162.1 207.1,208.1 238.3,207.7 284.8,207.7" />
            <polygon fill="#F5841F" points="103.6,138.2 51.3,153.5 33.9,207.7 80.3,207.7 111.4,208.1 87.8,162.1" />
            <polygon
              fill="#F5841F"
              points="174.6,164.6 177.9,106.9 193.1,65.8 125.6,65.8 140.6,106.9 144.1,164.6 145.3,182.8 145.4,227.6 173.1,227.6 173.3,182.8"
            />
          </svg>
        </div>
      ),
      coinbase: (
        <div className="w-full h-full rounded-full bg-gradient-to-br from-blue-100 to-blue-50 p-2 flex items-center justify-center">
          <svg viewBox="0 0 1024 1024" className="w-full h-full">
            <circle cx="512" cy="512" r="512" fill="#0052FF" />
            <path
              d="M512 192c176.731 0 320 143.269 320 320s-143.269 320-320 320-320-143.269-320-320 143.269-320 320-320z"
              fill="#FFF"
            />
            <path
              d="M512 352c-88.366 0-160 71.634-160 160s71.634 160 160 160 160-71.634 160-160-71.634-160-160-160zm0 256c-52.935 0-96-43.065-96-96s43.065-96 96-96 96 43.065 96 96-43.065 96-96 96z"
              fill="#0052FF"
            />
          </svg>
        </div>
      ),
      builtin: (
        <div className="w-full h-full rounded-full bg-gradient-to-br from-primary/20 to-primary/10 flex items-center justify-center">
          <Wallet className="w-6 h-6 sm:w-7 sm:h-7 text-primary" />
        </div>
      ),
    }
    return logos[provider.toLowerCase()] || logos.builtin
  }

const activeTheme = getWalletTheme(activeWallet.provider)

console.log("[v0 WalletDashboard] Rendering with activeWallet.address:", activeWallet?.address)
  console.log("[v0 WalletDashboard] activeProvider exists:", !!activeProvider)

console.log("[v0 WalletDashboard] activeWallet:", activeWallet)
  console.log("[v0 WalletDashboard] activeWallet.address:", activeWallet?.address)

useEffect(() => {
    console.log("[v0 WalletDashboard] Connected wallets count:", connectedWallets.length)
    console.log("[v0 WalletDashboard] Active wallet:", activeWallet?.name, activeWallet?.address)
    console.log(
      "[v0 WalletDashboard] All connected wallets:",
      connectedWallets.map((w) => `${w.name} (${w.address})`),
    )
  }, [connectedWallets, activeWallet])

return (
    <div className="space-y-4">
      <div className="text-xs text-center text-muted-foreground bg-muted/30 p-2 rounded font-mono">
        Connected: {connectedWallets.length} wallet(s) | Active: {activeWallet?.name || "None"}
      </div>

{connectedWallets.length > 1 && (
        <Card className="p-4 border-2 border-primary/50 bg-gradient-to-br from-primary/10 to-transparent">
          <div className="mb-3 flex items-center justify-between">
            <h3 className="text-base font-bold text-foreground flex items-center gap-2">
              <Wallet className="w-5 h-5 text-primary" />
              Switch Wallets ({connectedWallets.length})
            </h3>
            <button
              onClick={() => setShowWalletSelector(!showWalletSelector)}
              className="text-xs px-3 py-1 rounded-full bg-primary text-primary-foreground font-medium hover:bg-primary/90 transition-colors"
            >
              {showWalletSelector ? "Close" : "Open"}
            </button>
          </div>

<button
            onClick={() => setShowWalletSelector(!showWalletSelector)}
            className="w-full flex items-center justify-between p-3 sm:p-4 rounded-lg bg-background hover:bg-accent/50 transition-colors border-2 border-primary"
          >
            <div className="flex items-center gap-3 min-w-0 flex-1">
              <div className="relative flex-shrink-0">
                <div className="w-12 h-12 sm:w-14 sm:h-14 rounded-full overflow-hidden shadow-lg">
                  {getWalletLogo(activeWallet.provider)}
                </div>
                <div className="absolute -top-1 -right-1 w-4 h-4 sm:w-5 sm:h-5 bg-green-500 rounded-full border-2 border-background flex items-center justify-center">
                  <Check className="w-2.5 h-2.5 sm:w-3 sm:h-3 text-white" />
                </div>
              </div>
              <div className="text-left min-w-0 flex-1">
                <div className="flex items-center gap-2 mb-1 flex-wrap">
                  <p className="font-bold text-foreground text-base sm:text-lg truncate">{activeWallet.name}</p>
                  <span className="text-xs px-2 py-0.5 rounded-full bg-green-500 text-white font-medium flex-shrink-0">
                    Active
                  </span>
                </div>
                <p className="text-xs sm:text-sm text-muted-foreground font-mono">
                  {activeWallet.address.slice(0, 6)}...{activeWallet.address.slice(-4)}
                </p>
                <p className="text-xs font-medium text-foreground mt-0.5">
                  {accountBalances[activeWallet.address.toLowerCase()] ??
                    (tokens.length > 0 ? tokens[0].balance.toFixed(4) : activeWallet.balance)}{" "}
                  ETH
                </p>
              </div>
            </div>
            <ChevronDown
              className={`w-5 h-5 flex-shrink-0 transition-transform ${showWalletSelector ? "rotate-180" : ""}`}
            />
          </button>

{showWalletSelector && (
            <div className="mt-3 space-y-2 p-2 sm:p-3 bg-muted/20 rounded-lg border border-border">
              <p className="text-xs text-muted-foreground font-semibold mb-2 uppercase tracking-wide px-1">
                All Wallets
              </p>
              {connectedWallets
                .filter((wallet) => wallet.address.toLowerCase() !== activeWallet.address.toLowerCase())
                .map((wallet) => {
                  return (
                    <div
                      key={wallet.address}
                      className="flex items-center justify-between p-2 sm:p-3 rounded-lg border-2 border-transparent hover:border-border hover:bg-accent cursor-pointer transition-all"
                    >
                      <button
                        onClick={() => {
                          console.log("[v0 DASHBOARD] Switching to wallet:", wallet.name, wallet.address)
                          onSwitchWallet(wallet)
                          setShowWalletSelector(false)
                        }}
                        className="flex items-center gap-2 sm:gap-3 flex-1 text-left min-w-0"
                      >
                        <div className="relative flex-shrink-0">
                          <div className="w-10 h-10 sm:w-12 sm:h-12 rounded-full overflow-hidden shadow-sm border border-border/50">
                            {getWalletLogo(wallet.provider)}
                          </div>
                        </div>
                        <div className="min-w-0 flex-1">
                          <p className="font-semibold text-foreground text-sm sm:text-base truncate">{wallet.name}</p>
                          <p className="text-xs text-muted-foreground font-mono">
                            {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                          </p>
                          <p className="text-xs font-medium text-foreground">
                            {accountBalances[wallet.address.toLowerCase()] ?? wallet.balance} ETH
                          </p>
                        </div>
                      </button>
                      <button
                        onClick={(e) => {
                          e.stopPropagation()
                          console.log("[v0 DASHBOARD] Disconnecting wallet:", wallet.address)
                          onDisconnectWallet(wallet.address)
                        }}
                        className="p-2 hover:bg-destructive/10 rounded-lg transition-colors flex-shrink-0"
                        title="Disconnect wallet"
                      >
                        <X className="w-4 h-4 text-destructive" />
                      </button>
                    </div>
                  )
                })}
            </div>
          )}
        </Card>
      )}

{connectedWallets.length === 1 && (
        <div className="text-center p-4 bg-muted/20 rounded-lg border border-border">
          <p className="text-sm text-muted-foreground">Connect an external wallet to enable wallet switching</p>
        </div>
      )}

<Card className="border-2 border-primary/20">
        <div className="p-6 border-b border-border bg-gradient-to-r from-primary/5 to-transparent">
          <div className="flex items-center justify-between">
            <div className="flex items-center gap-3">
              <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
                <Send className="w-5 h-5 text-primary" />
              </div>
              <div>
                <h3 className="text-lg font-bold text-foreground">Payments & Transfers</h3>
                <p className="text-sm text-muted-foreground">
                  Send, request, and manage crypto as @username instead of wallet addresses
                </p>
              </div>
            </div>
          </div>
        </div>

<div className="p-6">
          <Tabs defaultValue="send" className="w-full">
            <TabsList className="grid w-full grid-cols-3 gap-3 h-auto bg-transparent p-0">
              <TabsTrigger
                value="send"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <Send className="w-10 h-10" />
                <span className="font-semibold text-base">Send</span>
              </TabsTrigger>
              <TabsTrigger
                value="request"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <QrCode className="w-10 h-10" />
                <span className="font-semibold text-base">Request</span>
              </TabsTrigger>
              <TabsTrigger
                value="store"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <Store className="w-10 h-10" />
                <span className="font-semibold text-base">Pay At Store</span>
              </TabsTrigger>
              <TabsTrigger
                value="buy"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <ShoppingBag className="w-10 h-10" />
                <span className="font-semibold text-base">Buy Crypto</span>
              </TabsTrigger>
              <TabsTrigger
                value="swap"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <ArrowDownUp className="w-10 h-10" />
                <span className="font-semibold text-base">Swap</span>
              </TabsTrigger>
              <TabsTrigger
                value="tokens"
                className="flex flex-col items-center justify-center gap-3 h-28 rounded-2xl border-2 border-border bg-card data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=active]:border-primary shadow-sm hover:shadow-md transition-all"
              >
                <Coins className="w-10 h-10" />
                <span className="font-semibold text-base">Tokens</span>
              </TabsTrigger>
            </TabsList>
            <TabsContent value="send" className="mt-6">
              <PaymentSend
                walletAddress={activeWallet.address}
                token="ETH"
                activeWallet={activeWallet}
                connectedWallets={connectedWallets}
                onSwitchWallet={onSwitchWallet}
                activeProvider={activeProvider}
                unlockedWalletData={unlockedWalletData}
              />
            </TabsContent>
            <TabsContent value="request" className="mt-6">
              <PaymentRequest
                walletAddress={activeWallet.address}
                connectedWallets={connectedWallets}
                activeWallet={activeWallet}
                onSwitchWallet={onSwitchWallet}
              />
            </TabsContent>
            <TabsContent value="store" className="mt-6">
              <PaymentLinkGenerator
                walletAddress={activeWallet.address}
                connectedWallets={connectedWallets}
                activeWallet={activeWallet}
                onSwitchWallet={onSwitchWallet}
              />
            </TabsContent>
            <TabsContent value="buy" className="mt-6">
              <AddMoneyInterface address={activeWallet.address} />
            </TabsContent>
            <TabsContent value="swap" className="mt-6">
              <SwapInterface address={activeWallet.address} />
            </TabsContent>
            <TabsContent value="tokens" className="mt-6">
              <TokenManager walletAddress={activeWallet.address} provider={activeProvider} />
            </TabsContent>
          </Tabs>
        </div>
      </Card>

<Card className="p-8 bg-gradient-to-br from-primary/5 to-success/5 border-border">
        <div className="flex items-start justify-between mb-6">
          <div>
            <div className="flex items-center gap-2 mb-1">
              <p className="text-sm text-muted-foreground">Total Portfolio Value</p>
              <Button
                variant="ghost"
                size="sm"
                onClick={async () => {
                  setIsLoadingTokens(true)
                  try {
                    // Use API route for balance fetch
                    const response = await fetch(`/api/balance?address=${activeWallet.address}`)
                    const data = await response.json()
                    
                    let balanceEth = 0
                    if (data.balanceEth) {
                      balanceEth = parseFloat(data.balanceEth)
                    }
                    
                    // Ethereum mainnet ETH - use real USD price from API
                    const ethPrice = data.ethPrice || 0
                    const change24h = data.change24h || 0
                    const usdValue = data.usdValue ?? balanceEth * ethPrice
                    
                    setTokens([{
                      symbol: "ETH",
                      balance: balanceEth,
                      price: ethPrice,
                      value: usdValue,
                      change24h,
                    }])
                    setPortfolioValue(usdValue)
                    setPortfolioChange(change24h)

// Refresh live balances for all connected accounts
                    const allResults = await Promise.all(
                      connectedWallets.map(async (w) => {
                        try {
                          const r = await fetch(`/api/balance?address=${w.address}`)
                          const d = await r.json()
                          const eth = d.balanceEth ? parseFloat(d.balanceEth).toFixed(4) : "0.0000"
                          return [w.address.toLowerCase(), eth] as const
                        } catch {
                          return [w.address.toLowerCase(), "0.0000"] as const
                        }
                      }),
                    )
                    setAccountBalances((prev) => {
                      const next = { ...prev }
                      for (const [addr, eth] of allResults) next[addr] = eth
                      return next
                    })
                  } catch (error) {
                    console.error("Error refreshing prices:", error)
                  } finally {
                    setIsLoadingTokens(false)
                  }
                }}
                disabled={isLoadingTokens}
                className="h-6 w-6 p-0"
              >
                <RefreshCw className={`w-3 h-3 ${isLoadingTokens ? "animate-spin" : ""}`} />
              </Button>
            </div>
            <h2 className="text-5xl font-bold text-foreground">
              {isLoadingTokens ? (
                <span className="text-muted-foreground">Loading...</span>
              ) : (
                formatPrice(portfolioValue)
              )}
            </h2>
            <p className="text-lg text-muted-foreground mt-1">
              {tokens.length > 0 ? tokens[0].balance.toFixed(4) : activeWallet.balance} ETH
            </p>
            <p
              className={`text-sm mt-2 flex items-center gap-1 ${portfolioChange >= 0 ? "text-success" : "text-destructive"}`}
            >
              {portfolioChange >= 0 ? <TrendingUp className="w-4 h-4" /> : <TrendingDown className="w-4 h-4" />}
              <span>{formatChange(portfolioChange)} (24h)</span>
            </p>
          </div>
          <div className="flex flex-col items-end gap-2">
            <div className="w-12 h-12 rounded-full bg-primary/10 flex items-center justify-center">
              <Wallet className="w-6 h-6 text-primary" />
            </div>
            <Button
              variant="outline"
              size="sm"
              onClick={async () => {
                try {
                  console.log("[v0 Logout] Sign out button clicked")

// Sign out from Supabase if authenticated
                  if (user) {
                    console.log("[v0 Logout] Signing out from Supabase")
                    await supabase.auth.signOut()
                    setUser(null)
                    setProfile(null)
                  }

console.log("[v0 Logout] Clearing wallet session data")

// Clear sessionStorage
                  sessionStorage.removeItem("linkficrypto_wallet_session")
                  sessionStorage.removeItem("unlockedWallet")
                  sessionStorage.clear() // Clear all session storage

// Clear localStorage
                  localStorage.removeItem("activeWallet")
                  localStorage.removeItem("linkficrypto_encrypted_wallet")
                  localStorage.removeItem("lastConnectedWallet")

// Clear global wallet provider
                  if (typeof window !== "undefined") {
                    if (window.builtInWalletProvider) {
                      window.builtInWalletProvider = undefined
                    }
                    // Also clear ethereum provider if exists
                    if ((window as any).ethereum) {
                      try {
                        // Some wallets support disconnect
                        if ((window as any).ethereum.disconnect) {
                          await (window as any).ethereum.disconnect()
                        }
                      } catch (e) {
                        console.log("[v0 Logout] Ethereum disconnect not supported")
                      }
                    }
                  }

console.log("[v0 Logout] All data cleared, redirecting to home page")

// Use router for cleaner navigation on desktop
                  router.push("/")
                  router.refresh()

// Fallback to hard redirect after a brief delay if router doesn't work
                  setTimeout(() => {
                    window.location.href = "/"
                  }, 100)
                } catch (error) {
                  console.error("[v0 Logout] Error during sign out:", error)
                  // Still try to redirect even if there's an error
                  window.location.href = "/"
                }
              }}
              className="text-destructive hover:text-destructive hover:bg-destructive/10 bg-transparent"
            >
              <LogOut className="w-4 h-4 mr-2" />
              Sign Out
            </Button>
          </div>
        </div>

<div className="flex items-center gap-2 p-2 sm:p-3 rounded-lg bg-background/50 border border-border">
          <span className="text-xs sm:text-sm font-mono text-foreground truncate max-w-[180px] sm:max-w-none">
            {activeWallet.address.slice(0, 10)}...{activeWallet.address.slice(-8)}
          </span>
          <Button
            variant="ghost"
            size="sm"
            onClick={() => {
              const formattedAddress = activeWallet.address.startsWith("0x")
                ? activeWallet.address
                : `0x${activeWallet.address}`
              navigator.clipboard.writeText(formattedAddress)
              setCopied(true)
              setTimeout(() => setCopied(false), 2000)
            }}
            className="h-7 w-7 sm:h-8 sm:w-8 p-0 flex-shrink-0"
          >
            {copied ? (
              <Check className="w-3 h-3 sm:w-4 sm:h-4 text-success" />
            ) : (
              <Copy className="w-3 h-3 sm:w-4 sm:h-4" />
            )}
          </Button>
          <Button variant="ghost" size="sm" asChild className="h-7 w-7 sm:h-8 sm:w-8 p-0 flex-shrink-0">
            <a
              href={`https://etherscan.io/address/${activeWallet.address.startsWith("0x") ? activeWallet.address : `0x${activeWallet.address}`}`}
              target="_blank"
              rel="noopener noreferrer"
            >
              <ExternalLink className="w-3 h-3 sm:w-4 sm:h-4" />
            </a>
          </Button>
        </div>
      </Card>

<SimpleTransactionList
        walletAddress={activeWallet.address.startsWith("0x") ? activeWallet.address : `0x${activeWallet.address}`}
      />
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/payments-dashboard.tsx"
"use client"

interface PaymentsDashboardProps {
  walletAddress: string
  connectedWallets?: Array<{ address: string; balance: string; provider: string; name: string }>
  activeWallet?: { address: string; balance: string; provider: string; name: string } | null
  onSwitchWallet?: (wallet: { address: string; balance: string; provider: string; name: string }) => void
}

export function PaymentsDashboard({
  walletAddress,
  connectedWallets = [],
  activeWallet = null,
  onSwitchWallet,
}: PaymentsDashboardProps) {
  const [user, setUser] = useState<any>(null)
  const [profile, setProfile] = useState<any>(null)
  const [loading, setLoading] = useState(true)
  const [editingUsername, setEditingUsername] = useState(false)
  const [newUsername, setNewUsername] = useState("")
  const [usernameError, setUsernameError] = useState("")
  const supabase = createClient()
  const router = useRouter()

useEffect(() => {
    checkUser()
  }, [walletAddress])

const checkUser = async () => {
    const isBuiltInWallet = hasWallet()

const {
      data: { user },
    } = await supabase.auth.getUser()

if (user) {
      setUser(user)

const { data: profileData } = await supabase.from("profiles").select("*").eq("id", user.id).single()

if (profileData) {
        setProfile(profileData)
      }
    } else if (isBuiltInWallet) {
      console.log("[v0] Built-in wallet detected, showing payment features without Supabase auth")
    }

setLoading(false)
  }

const handleSignOut = async () => {
    await supabase.auth.signOut()
    setUser(null)
    setProfile(null)
    router.push("/auth/login")
  }

const handleUpdateUsername = async () => {
    if (!newUsername) {
      setUsernameError("Username cannot be empty")
      return
    }

setLoading(true)
    setUsernameError("")

// Safe RPC; own-row RLS blocks direct cross-user reads
    const { data: existingUsers } = await supabase.rpc("get_profile_by_username", { uname: newUsername })

if (existingUsers && existingUsers.some((u: { id: string }) => u.id !== user.id)) {
      setUsernameError("Username is already taken")
      setLoading(false)
      return
    }

const { error } = await supabase.from("profiles").update({ username: newUsername }).eq("id", user.id)

if (error) {
      setUsernameError(error.message)
    } else {
      setProfile({ ...profile, username: newUsername })
      setEditingUsername(false)
      setNewUsername("")
    }

setLoading(false)
  }

const isBuiltInWallet = hasWallet()
  const shouldShowSignIn = !user && !profile && !isBuiltInWallet

if (shouldShowSignIn) {
    return (
      <Card>
        <CardHeader>
          <CardTitle>Payments & Transfers</CardTitle>
          <CardDescription>Sign in to enable payment features</CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <div className="bg-muted p-4 rounded-lg space-y-3">
            <p className="text-sm text-muted-foreground">Create an account to unlock payment features:</p>
            <ul className="text-sm text-muted-foreground space-y-2">
              <li className="flex items-start gap-2">
                <span className="text-primary mt-0.5">✓</span>
                <span>Send payments using @username instead of wallet addresses</span>
              </li>
              <li className="flex items-start gap-2">
                <span className="text-primary mt-0.5">✓</span>
                <span>Generate QR codes for receiving payments</span>
              </li>
              <li className="flex items-start gap-2">
                <span className="text-primary mt-0.5">✓</span>
                <span>Create payment links for your store</span>
              </li>
            </ul>
          </div>
          <div className="flex gap-2">
            <Button asChild className="flex-1 bg-black text-white hover:bg-black/90">
              <a href="/auth/sign-up">Create Account</a>
            </Button>
            <Button asChild variant="outline" className="flex-1 bg-transparent">
              <a href="/auth/login">
                <LogIn className="w-4 h-4 mr-2" />
                Sign In
              </a>
            </Button>
          </div>
        </CardContent>
      </Card>
    )
  }

if (isBuiltInWallet && !profile) {
    return (
      <Card>
        <CardHeader>
          <CardTitle>Payments & Transfers</CardTitle>
          <CardDescription>
            Send, request, and manage crypto as {walletAddress.slice(0, 6)}...{walletAddress.slice(-4)}
          </CardDescription>
        </CardHeader>
        <CardContent>
          <Tabs defaultValue="send" className="w-full">
            <TabsList className="grid w-full grid-cols-3">
              <TabsTrigger value="send">Send</TabsTrigger>
              <TabsTrigger value="request">Request</TabsTrigger>
              <TabsTrigger value="store">Pay At Store</TabsTrigger>
            </TabsList>
            <TabsContent value="send">
              <PaymentSend walletAddress={walletAddress} />
            </TabsContent>
            <TabsContent value="request">
              <PaymentRequest walletAddress={walletAddress} />
            </TabsContent>
            <TabsContent value="store">
              <PaymentLinkGenerator walletAddress={walletAddress} />
            </TabsContent>
          </Tabs>
        </CardContent>
      </Card>
    )
  }

return (
    <div className="space-y-4">
      {connectedWallets.length > 1 && (
        <Card>
          <CardHeader>
            <CardTitle className="text-sm font-medium">Active Wallet</CardTitle>
            <CardDescription className="text-xs">Switch between your connected wallets</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-2">
              {connectedWallets.map((wallet) => (
                <button
                  key={wallet.address}
                  onClick={() => onSwitchWallet?.(wallet)}
                  className={`w-full flex items-center justify-between p-3 rounded-lg border-2 transition-all ${
                    activeWallet?.address === wallet.address
                      ? "bg-primary text-primary-foreground border-primary"
                      : "bg-card text-card-foreground border-border hover:border-primary/50"
                  }`}
                >
                  <div className="flex items-center gap-3">
                    <div className="h-10 w-10 rounded-full bg-gradient-to-br from-blue-500 to-purple-600 flex items-center justify-center text-white font-bold text-sm">
                      {wallet.name.charAt(0).toUpperCase()}
                    </div>
                    <div className="text-left">
                      <div className="font-semibold text-sm">{wallet.name}</div>
                      <div className="text-xs opacity-75">
                        {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                      </div>
                    </div>
                  </div>
                  <div className="text-right">
                    <div className="font-semibold text-sm">{wallet.balance} ETH</div>
                    {activeWallet?.address === wallet.address && <div className="text-xs opacity-75">Active</div>}
                  </div>
                </button>
              ))}
            </div>
          </CardContent>
        </Card>
      )}

{profile && (
        <Card>
          <CardHeader>
            <div className="flex items-center justify-between">
              <div className="flex items-center gap-3 flex-1">
                <User className="h-5 w-5" />
                <div className="flex-1">
                  {editingUsername ? (
                    <div className="space-y-2">
                      <div className="flex gap-2 items-start">
                        <div className="flex-1">
                          <div className="flex">
                            <span className="inline-flex items-center px-3 rounded-l-md border border-r-0 border-input bg-muted text-muted-foreground text-sm">
                              @
                            </span>
                            <Input
                              value={newUsername}
                              onChange={(e) => setNewUsername(e.target.value.toLowerCase().replace(/[^a-z0-9_]/g, ""))}
                              placeholder="username"
                              className="rounded-l-none"
                            />
                          </div>
                          {usernameError && <p className="text-xs text-red-500 mt-1">{usernameError}</p>}
                        </div>
                        <Button onClick={handleUpdateUsername} size="sm" disabled={loading}>
                          Save
                        </Button>
                        <Button onClick={() => setEditingUsername(false)} size="sm" variant="outline">
                          Cancel
                        </Button>
                      </div>
                    </div>
                  ) : (
                    <div className="flex items-center gap-2">
                      <CardTitle className="text-lg">@{profile.username}</CardTitle>
                      <Button
                        onClick={() => {
                          setEditingUsername(true)
                          setNewUsername(profile.username)
                        }}
                        size="sm"
                        variant="ghost"
                        className="h-6 w-6 p-0"
                      >
                        <Edit className="h-3 w-3" />
                      </Button>
                    </div>
                  )}
                  <CardDescription className="text-xs">
                    {walletAddress.slice(0, 6)}...{walletAddress.slice(-4)}
                  </CardDescription>
                </div>
              </div>
              <Button onClick={handleSignOut} variant="ghost" size="sm">
                <LogOut className="h-4 w-4 mr-2" />
                Sign Out
              </Button>
            </div>
          </CardHeader>
        </Card>
      )}

<Card>
        <CardHeader>
          <CardTitle>Payments & Transfers</CardTitle>
          <CardDescription>
            Send, request, and manage crypto as {profile ? `@${profile.username}` : walletAddress.slice(0, 10) + "..."}
          </CardDescription>
        </CardHeader>
        <CardContent>
          <Tabs defaultValue="send" className="w-full">
            <TabsList className="grid w-full grid-cols-3">
              <TabsTrigger value="send">Send</TabsTrigger>
              <TabsTrigger value="request">Request</TabsTrigger>
              <TabsTrigger value="store">Pay At Store</TabsTrigger>
            </TabsList>
            <TabsContent value="send">
              <PaymentSend walletAddress={walletAddress} />
            </TabsContent>
            <TabsContent value="request">
              <PaymentRequest walletAddress={walletAddress} />
            </TabsContent>
            <TabsContent value="store">
              <PaymentLinkGenerator walletAddress={walletAddress} />
            </TabsContent>
          </Tabs>
        </CardContent>
      </Card>
    </div>
  )
}b3:Tf0f94,[V0_FILE]typescriptreact:file="components/ui/input.tsx" isMerged="true"
import * as React from "react"

import { cn } from "@/lib/utils"

const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
  ({ className, type, ...props }, ref) => {
    return (
      <input
        type={type}
        className={cn(
          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
          className,
        )}
        ref={ref}
        {...props}
      />
    )
  },
)
Input.displayName = "Input"

export { Input }
[V0_FILE]xml:file="public/sitemap.xml" isMerged="true"
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://linkficrypto.com</loc>
    <lastmod>2025-01-01</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
</urlset>
[V0_FILE]plaintext:file="public/robots.txt" isMerged="true"
# Allow all search engines to crawl the site
User-agent: *
Allow: /

# Sitemap location
Sitemap: https://linkficrypto.com/sitemap.xml
[V0_FILE]typescriptreact:file="components/token-manager.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Plus, Eye, EyeOff, Trash2, RefreshCw } from "lucide-react"
import { Badge } from "@/components/ui/badge"

interface Token {
  address: string
  symbol: string
  name: string
  decimals: number
  balance: string
  balanceUSD?: string
  logoURI?: string
  isCustom?: boolean
}

interface TokenManagerProps {
  walletAddress: string
  provider: any
}

export function TokenManager({ walletAddress, provider }: TokenManagerProps) {
  const [tokens, setTokens] = useState<Token[]>([])
  const [hiddenTokens, setHiddenTokens] = useState<Set<string>>(new Set())
  const [showAddToken, setShowAddToken] = useState(false)
  const [isLoading, setIsLoading] = useState(false)
  const [customTokenAddress, setCustomTokenAddress] = useState("")

// ERC-20 ABI for balanceOf and token info
  const ERC20_ABI = [
    "function balanceOf(address) view returns (uint256)",
    "function symbol() view returns (string)",
    "function name() view returns (string)",
    "function decimals() view returns (uint8)",
  ]

useEffect(() => {
    loadTokens()
  }, [walletAddress])

const loadTokens = async () => {
    setIsLoading(true)
    try {
      // Load popular tokens (you can expand this list)
      const popularTokens = [
        {
          address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
          symbol: "USDT",
          name: "Tether USD",
          decimals: 6,
        },
        {
          address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
          symbol: "USDC",
          name: "USD Coin",
          decimals: 6,
        },
        {
          address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
          symbol: "DAI",
          name: "Dai Stablecoin",
          decimals: 18,
        },
        {
          address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
          symbol: "WBTC",
          name: "Wrapped BTC",
          decimals: 8,
        },
      ]

const tokenBalances = await Promise.all(
        popularTokens.map(async (token) => {
          try {
            const balance = await provider.request({
              method: "eth_call",
              params: [
                {
                  to: token.address,
                  data: `0x70a08231000000000000000000000000${walletAddress.slice(2)}`,
                },
                "latest",
              ],
            })

const balanceNum = Number.parseInt(balance, 16) / Math.pow(10, token.decimals)
            return {
              ...token,
              balance: balanceNum.toFixed(4),
            }
          } catch (error) {
            return {
              ...token,
              balance: "0.0000",
            }
          }
        }),
      )

setTokens(tokenBalances.filter((t) => Number.parseFloat(t.balance) > 0))
    } catch (error) {
      console.error("Error loading tokens:", error)
    } finally {
      setIsLoading(false)
    }
  }

const addCustomToken = async () => {
    if (!customTokenAddress || !customTokenAddress.startsWith("0x")) {
      alert("Please enter a valid token address")
      return
    }

setIsLoading(true)
    try {
      // Get token info
      const symbolData = await provider.request({
        method: "eth_call",
        params: [{ to: customTokenAddress, data: "0x95d89b41" }, "latest"],
      })

const nameData = await provider.request({
        method: "eth_call",
        params: [{ to: customTokenAddress, data: "0x06fdde03" }, "latest"],
      })

const decimalsData = await provider.request({
        method: "eth_call",
        params: [{ to: customTokenAddress, data: "0x313ce567" }, "latest"],
      })

const balanceData = await provider.request({
        method: "eth_call",
        params: [
          {
            to: customTokenAddress,
            data: `0x70a08231000000000000000000000000${walletAddress.slice(2)}`,
          },
          "latest",
        ],
      })

const decimals = Number.parseInt(decimalsData, 16)
      const balance = Number.parseInt(balanceData, 16) / Math.pow(10, decimals)

// Decode hex strings (simplified)
      const symbol = hexToString(symbolData)
      const name = hexToString(nameData)

const newToken: Token = {
        address: customTokenAddress,
        symbol,
        name,
        decimals,
        balance: balance.toFixed(4),
        isCustom: true,
      }

setTokens([...tokens, newToken])
      setCustomTokenAddress("")
      setShowAddToken(false)
    } catch (error) {
      console.error("Error adding custom token:", error)
      alert("Failed to add token. Please check the address and try again.")
    } finally {
      setIsLoading(false)
    }
  }

const hexToString = (hex: string): string => {
    try {
      const cleaned = hex.replace("0x", "")
      let str = ""
      for (let i = 0; i < cleaned.length; i += 2) {
        const charCode = Number.parseInt(cleaned.substr(i, 2), 16)
        if (charCode > 0) str += String.fromCharCode(charCode)
      }
      return str.trim()
    } catch {
      return "Unknown"
    }
  }

const toggleTokenVisibility = (address: string) => {
    const newHidden = new Set(hiddenTokens)
    if (newHidden.has(address)) {
      newHidden.delete(address)
    } else {
      newHidden.add(address)
    }
    setHiddenTokens(newHidden)
  }

const removeCustomToken = (address: string) => {
    setTokens(tokens.filter((t) => t.address !== address))
  }

const visibleTokens = tokens.filter((t) => !hiddenTokens.has(t.address))

return (
    <Card className="p-6">
      <div className="flex items-center justify-between mb-6">
        <h3 className="text-lg font-semibold">Token Balances</h3>
        <div className="flex gap-2">
          <Button variant="outline" size="sm" onClick={loadTokens} disabled={isLoading}>
            <RefreshCw className={`w-4 h-4 ${isLoading ? "animate-spin" : ""}`} />
          </Button>
          <Button variant="outline" size="sm" onClick={() => setShowAddToken(!showAddToken)}>
            <Plus className="w-4 h-4 mr-2" />
            Add Token
          </Button>
        </div>
      </div>

{showAddToken && (
        <div className="mb-6 p-4 border rounded-lg">
          <h4 className="text-sm font-medium mb-3">Add Custom Token</h4>
          <div className="flex gap-2">
            <Input
              placeholder="Token Contract Address (0x...)"
              value={customTokenAddress}
              onChange={(e) => setCustomTokenAddress(e.target.value)}
            />
            <Button onClick={addCustomToken} disabled={isLoading}>
              Add
            </Button>
          </div>
        </div>
      )}

<div className="space-y-3">
        {visibleTokens.length === 0 ? (
          <div className="text-center py-8 text-muted-foreground">
            <p>No tokens found</p>
            <p className="text-sm mt-2">Add custom tokens or wait for balances to load</p>
          </div>
        ) : (
          visibleTokens.map((token) => (
            <div key={token.address} className="flex items-center justify-between p-4 border rounded-lg">
              <div className="flex items-center gap-3">
                <div className="w-10 h-10 rounded-full bg-primary/10 flex items-center justify-center">
                  <span className="text-sm font-bold">{token.symbol.slice(0, 2)}</span>
                </div>
                <div>
                  <div className="flex items-center gap-2">
                    <p className="font-medium">{token.symbol}</p>
                    {token.isCustom && <Badge variant="secondary">Custom</Badge>}
                  </div>
                  <p className="text-sm text-muted-foreground">{token.name}</p>
                </div>
              </div>
              <div className="flex items-center gap-3">
                <div className="text-right">
                  <p className="font-medium">{token.balance}</p>
                  {token.balanceUSD && <p className="text-sm text-muted-foreground">${token.balanceUSD}</p>}
                </div>
                <div className="flex gap-1">
                  <Button
                    variant="ghost"
                    size="sm"
                    onClick={() => toggleTokenVisibility(token.address)}
                    className="h-8 w-8 p-0"
                  >
                    <Eye className="w-4 h-4" />
                  </Button>
                  {token.isCustom && (
                    <Button
                      variant="ghost"
                      size="sm"
                      onClick={() => removeCustomToken(token.address)}
                      className="h-8 w-8 p-0 text-destructive"
                    >
                      <Trash2 className="w-4 h-4" />
                    </Button>
                  )}
                </div>
              </div>
            </div>
          ))
        )}
      </div>

{hiddenTokens.size > 0 && (
        <div className="mt-4 pt-4 border-t">
          <Button variant="ghost" size="sm" className="w-full" onClick={() => setHiddenTokens(new Set())}>
            <EyeOff className="w-4 h-4 mr-2" />
            Show {hiddenTokens.size} Hidden Token{hiddenTokens.size > 1 ? "s" : ""}
          </Button>
        </div>
      )}
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/network-switcher.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { Check, ChevronDown } from "lucide-react"

interface Network {
  chainId: string
  name: string
  rpcUrl: string
  symbol: string
  explorer: string
  icon: string
}

interface NetworkSwitcherProps {
  provider: any
  onNetworkChange?: (network: Network) => void
}

export function NetworkSwitcher({ provider, onNetworkChange }: NetworkSwitcherProps) {
  const [currentNetwork, setCurrentNetwork] = useState<Network | null>(null)
  const [showNetworks, setShowNetworks] = useState(false)
  const [isSwitching, setIsSwitching] = useState(false)

const networks: Network[] = [
    {
      chainId: "0x1",
      name: "Ethereum Mainnet",
      rpcUrl: "https://mainnet.infura.io/v3/",
      symbol: "ETH",
      explorer: "https://etherscan.io",
      icon: "⟠",
    },
    {
      chainId: "0x38",
      name: "BNB Smart Chain",
      rpcUrl: "https://bsc-dataseed.binance.org/",
      symbol: "BNB",
      explorer: "https://bscscan.com",
      icon: "🔶",
    },
    {
      chainId: "0x89",
      name: "Polygon",
      rpcUrl: "https://polygon-rpc.com/",
      symbol: "MATIC",
      explorer: "https://polygonscan.com",
      icon: "🟣",
    },
    {
      chainId: "0xa4b1",
      name: "Arbitrum One",
      rpcUrl: "https://arb1.arbitrum.io/rpc",
      symbol: "ETH",
      explorer: "https://arbiscan.io",
      icon: "🔵",
    },
    {
      chainId: "0xa",
      name: "Optimism",
      rpcUrl: "https://mainnet.optimism.io",
      symbol: "ETH",
      explorer: "https://optimistic.etherscan.io",
      icon: "🔴",
    },
    {
      chainId: "0xa86a",
      name: "Avalanche C-Chain",
      rpcUrl: "https://api.avax.network/ext/bc/C/rpc",
      symbol: "AVAX",
      explorer: "https://snowtrace.io",
      icon: "🔺",
    },
  ]

useEffect(() => {
    getCurrentNetwork()
  }, [provider])

const getCurrentNetwork = async () => {
    try {
      const chainId = await provider.request({ method: "eth_chainId" })
      const network = networks.find((n) => n.chainId === chainId)
      setCurrentNetwork(network || networks[0])
    } catch (error) {
      console.error("Error getting current network:", error)
    }
  }

const switchNetwork = async (network: Network) => {
    setIsSwitching(true)
    try {
      await provider.request({
        method: "wallet_switchEthereumChain",
        params: [{ chainId: network.chainId }],
      })
      setCurrentNetwork(network)
      setShowNetworks(false)
      onNetworkChange?.(network)
    } catch (error: any) {
      // If network doesn't exist, add it
      if (error.code === 4902) {
        try {
          await provider.request({
            method: "wallet_addEthereumChain",
            params: [
              {
                chainId: network.chainId,
                chainName: network.name,
                nativeCurrency: {
                  name: network.symbol,
                  symbol: network.symbol,
                  decimals: 18,
                },
                rpcUrls: [network.rpcUrl],
                blockExplorerUrls: [network.explorer],
              },
            ],
          })
          setCurrentNetwork(network)
          setShowNetworks(false)
          onNetworkChange?.(network)
        } catch (addError) {
          console.error("Error adding network:", addError)
        }
      } else {
        console.error("Error switching network:", error)
      }
    } finally {
      setIsSwitching(false)
    }
  }

return (
    <div className="relative">
      <Button
        variant="outline"
        onClick={() => setShowNetworks(!showNetworks)}
        disabled={isSwitching}
        className="w-full justify-between"
      >
        <span className="flex items-center gap-2">
          <span className="text-xl">{currentNetwork?.icon || "⟠"}</span>
          <span>{currentNetwork?.name || "Select Network"}</span>
        </span>
        <ChevronDown className="w-4 h-4" />
      </Button>

{showNetworks && (
        <Card className="absolute top-full mt-2 w-full z-50 p-2 max-h-96 overflow-y-auto">
          {networks.map((network) => (
            <button
              key={network.chainId}
              onClick={() => switchNetwork(network)}
              disabled={isSwitching}
              className="w-full p-3 rounded-lg hover:bg-accent transition-colors flex items-center justify-between disabled:opacity-50"
            >
              <span className="flex items-center gap-3">
                <span className="text-xl">{network.icon}</span>
                <div className="text-left">
                  <p className="font-medium">{network.name}</p>
                  <p className="text-xs text-muted-foreground">{network.symbol}</p>
                </div>
              </span>
              {currentNetwork?.chainId === network.chainId && <Check className="w-4 h-4 text-primary" />}
            </button>
          ))}
        </Card>
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/message-signer.tsx" isFixed="true" isQuickEdit="true" isMerged="true"
"use client"

import { useState } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Textarea } from "@/components/ui/textarea"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { Copy, Check } from "lucide-react"

interface MessageSignerProps {
  walletAddress: string
  provider: any
}

export function MessageSigner({ walletAddress, provider }: MessageSignerProps) {
  const [message, setMessage] = useState("")
  const [signature, setSignature] = useState("")
  const [verifyMessage, setVerifyMessage] = useState("")
  const [verifySigInput, setVerifySigInput] = useState("")
  const [verifyAddress, setVerifyAddress] = useState("")
  const [verifyResult, setVerifyResult] = useState<boolean | null>(null)
  const [isSigning, setIsSigning] = useState(false)
  const [isVerifying, setIsVerifying] = useState(false)
  const [copied, setCopied] = useState(false)

const signMessage = async () => {
    if (!message.trim()) {
      alert("Please enter a message to sign")
      return
    }

setIsSigning(true)
    try {
      const sig = await provider.request({
        method: "personal_sign",
        params: [message, walletAddress],
      })
      setSignature(sig)
    } catch (error) {
      console.error("Error signing message:", error)
      alert("Failed to sign message. Please try again.")
    } finally {
      setIsSigning(false)
    }
  }

const verifySignature = async () => {
    if (!verifyMessage.trim() || !verifySigInput.trim() || !verifyAddress.trim()) {
      alert("Please fill in all fields")
      return
    }

setIsVerifying(true)
    try {
      // Simple verification using eth_call (in production, use a proper library)
      const recovered = await provider.request({
        method: "personal_ecRecover",
        params: [verifyMessage, verifySigInput],
      })

setVerifyResult(recovered.toLowerCase() === verifyAddress.toLowerCase())
    } catch (error) {
      console.error("Error verifying signature:", error)
      setVerifyResult(false)
    } finally {
      setIsVerifying(false)
    }
  }

const copyToClipboard = (text: string) => {
    navigator.clipboard.writeText(text)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

return (
    <Card className="p-6">
      <h3 className="text-lg font-semibold mb-6">Message Signing</h3>

<Tabs defaultValue="sign">
        <TabsList className="grid w-full grid-cols-2">
          <TabsTrigger value="sign">Sign Message</TabsTrigger>
          <TabsTrigger value="verify">Verify Signature</TabsTrigger>
        </TabsList>

<TabsContent value="sign" className="space-y-4">
          <div>
            <Label htmlFor="message">Message to Sign</Label>
            <Textarea
              id="message"
              placeholder="Enter your message here..."
              value={message}
              onChange={(e) => setMessage(e.target.value)}
              rows={4}
              className="mt-2"
            />
          </div>