@usebutr/core 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,2 +1,1462 @@
-import{createStore as e}from"zustand/vanilla";const t=e=>({bitcoin:e.bitcoin??[],evm:e.evm??[],polkadot:e.polkadot??[],sui:e.sui??[],svm:e.svm??[]}),n=e=>{if(e instanceof Error){let t=e.message,n=t.toLowerCase();if(t===`Connection timeout`)return{kind:`Timeout`,message:t};if(t===`Failed to get account`||n.includes(`not connected`))return{kind:`NotConnected`,message:t};let r=e.code;return r===4001?{kind:`UserRejected`,message:t}:r===-32002?{kind:`RequestPending`,message:t}:r===4100||r===4900||r===4901?{kind:`NotConnected`,message:t}:n.includes(`user rejected`)||n.includes(`user denied`)?{kind:`UserRejected`,message:t}:n.includes(`locked`)?{kind:`WalletLocked`,message:t}:n.includes(`chain`)&&(n.includes(`mismatch`)||n.includes(`unsupported`))?{kind:`ChainMismatch`,message:t}:{cause:e,kind:`Unknown`,message:t}}return typeof e==`string`?{kind:`Unknown`,message:e}:{cause:e,kind:`Unknown`,message:`Connection failed`}},r=e=>({subscribe:e}),i=(...e)=>{console.warn(...e)},a=(...e)=>{console.error(...e)},o=e=>{try{return typeof globalThis<`u`&&globalThis[e]!==void 0}catch{return!1}},s=()=>{let e=new Map;return{getItem(t){return e.get(t)??null},removeItem(t){e.delete(t)},setItem(t,n){e.set(t,n)}}},c=e=>{if(!o(e))return s();let t=globalThis[e];return{getItem(e){try{return t.getItem(e)}catch{return null}},removeItem(e){try{t.removeItem(e)}catch{}},setItem(e,n){try{t.setItem(e,n)}catch{}}}},l=()=>({persistent:c(`localStorage`),session:c(`sessionStorage`)}),u=e=>encodeURIComponent(e),d=e=>decodeURIComponent(e),f=()=>{let e=new Map;if(typeof document>`u`)return e;let t=document.cookie;if(!t)return e;for(let n of t.split(`;`)){let t=n.trim();if(!t)continue;let r=t.indexOf(`=`);if(r===-1)continue;let i=t.slice(0,r),a=t.slice(r+1);try{e.set(i,d(a))}catch{}}return e},p=(e,t,n,r=!1)=>{let i=[`${e}=${u(t)}`,`Path=${n.path??`/`}`];if(n.domain&&i.push(`Domain=${n.domain}`),r)i.push(`Max-Age=0`);else{let e=n.maxAgeSeconds??2592e3;i.push(`Max-Age=${e}`)}return i.push(`SameSite=${n.sameSite??`lax`}`),(n.secure??!0)&&i.push(`Secure`),i.join(`; `)},m=e=>e?typeof e[Symbol.iterator]==`function`?new Map(e):new Map(Object.entries(e)):null,h=(e={})=>{let t=m(e.initialCookies);return typeof document>`u`?t?{getItem(e){return t.get(e)??null},removeItem(){},setItem(){}}:{getItem(){return null},removeItem(){},setItem(){}}:{getItem(e){return f().get(e)??null},removeItem(t){document.cookie=p(t,``,e,!0)},setItem(t,n){document.cookie=p(t,n,e)}}},g=new Set([`evm`,`svm`,`sui`,`bitcoin`]),_=Object.freeze({activeConnectorId:null,pool:Object.freeze({}),selection:Object.freeze({})}),v=e=>{if(typeof e[Symbol.iterator]!=`function`)return new Map(Object.entries(e));let t=new Map;for(let n of e){if(Array.isArray(n)){let[e,r]=n;typeof e==`string`&&typeof r==`string`&&t.set(e,r);continue}n&&typeof n==`object`&&`name`in n&&`value`in n&&typeof n.name==`string`&&typeof n.value==`string`&&t.set(n.name,n.value)}return t},y=e=>{if(!e||typeof e!=`object`)return!1;let t=e;return!(typeof t.walletAddress!=`string`||typeof t.id!=`string`||!t.chain||typeof t.chain!=`object`)},b=(e,t)=>{if(!t||typeof t!=`object`)return!1;let n=t;return!(typeof n.connectorId!=`string`||n.connectorId!==e||typeof n.chainPlatform!=`string`||!g.has(n.chainPlatform)||typeof n.name!=`string`||n.name.length===0||n.icon!==void 0&&typeof n.icon!=`string`||!y(n.account)||!Array.isArray(n.accounts)||!n.accounts.every(y))},x=e=>{if(!e)return{};try{let t=JSON.parse(e);if(!t||typeof t!=`object`)return{};let n={};for(let[e,r]of Object.entries(t))b(e,r)?n[e]=r:i(`[butr] readWalletSnapshot: dropping invalid pool entry for ${e}`);return n}catch(e){return i(`[butr] readWalletSnapshot: failed to parse pool cookie:`,e),{}}},S=e=>{if(!e)return{};try{let t=JSON.parse(e);if(!t||typeof t!=`object`)return{};let n={};for(let[e,r]of Object.entries(t))g.has(e)&&typeof r==`string`&&r.length>0&&(n[e]=r);return n}catch(e){return i(`[butr] readWalletSnapshot: failed to parse selection cookie:`,e),{}}},C=(e,t={})=>{let n=t.keyPrefix||`butr`,r=v(e),i=x(r.get(`${n}-pool`)),a=S(r.get(`${n}-selection`)),o=r.get(`${n}-active`),s=null;if(o&&o.length>0&&i[o])s=o;else{let e=Object.keys(i)[0];e&&(s=e)}return{activeConnectorId:s,pool:i,selection:a}},w=new Set([`evm`,`svm`,`sui`,`bitcoin`]),T=e=>{if(!e||typeof e!=`object`)return!1;let t=e;return!(typeof t.walletAddress!=`string`||typeof t.id!=`string`||!t.chain||typeof t.chain!=`object`)},E=(e,t)=>{if(!t||typeof t!=`object`)return!1;let n=t;return!(typeof n.connectorId!=`string`||n.connectorId!==e||typeof n.chainPlatform!=`string`||!w.has(n.chainPlatform)||typeof n.name!=`string`||n.name.length===0||n.icon!==void 0&&typeof n.icon!=`string`||!T(n.account)||!Array.isArray(n.accounts)||!n.accounts.every(T))};var D=class{poolKey;selectionKey;activeKey;userDisconnectedKey;persistent;session;poolMutationQueue=Promise.resolve();constructor(e){if(this.poolKey=`${e.keyPrefix}-pool`,this.selectionKey=`${e.keyPrefix}-selection`,this.activeKey=`${e.keyPrefix}-active`,this.userDisconnectedKey=`${e.keyPrefix}-user-disconnected`,e.persistent&&e.session)this.persistent=e.persistent,this.session=e.session;else{let t=l();this.persistent=e.persistent??t.persistent,this.session=e.session??t.session}}async serializePoolMutation(e){let t=this.poolMutationQueue,n=()=>{};this.poolMutationQueue=new Promise(e=>{n=e});try{await t}catch{}try{return await e()}finally{n()}}async getPool(){try{let e=await this.persistent.getItem(this.poolKey);if(!e)return{};let t=JSON.parse(e);if(!t||typeof t!=`object`)return await this.clearPool(),{};let n={};for(let[e,r]of Object.entries(t))E(e,r)?n[e]=r:i(`[butr] dropping invalid pool entry for ${e}`);return n}catch(e){return i(`[butr] failed to parse pool from storage:`,e),await this.clearPool(),{}}}setPool(e){return this.serializePoolMutation(async()=>{try{let t={...await this.getPool()};for(let[n,r]of e){let e={account:r.account,accounts:r.accounts,chainPlatform:r.connector.chainPlatform,connectorId:n,icon:r.connector.icon,name:r.connector.name};if(!E(n,e))throw Error(`[butr] refusing to persist invalid pool entry for ${n}`);t[n]=e}await this.persistent.setItem(this.poolKey,JSON.stringify(t))}catch(e){i(`[butr] failed to persist pool:`,e)}})}removePoolEntry(e){return this.serializePoolMutation(async()=>{try{let t=await this.getPool();if(t[e]){let{[e]:n,...r}=t;await this.persistent.setItem(this.poolKey,JSON.stringify(r))}}catch(t){i(`[butr] failed to remove pool entry ${e}:`,t)}})}clearPool(){return this.serializePoolMutation(async()=>{await this.persistent.removeItem(this.poolKey)})}async getSelection(){try{let e=await this.persistent.getItem(this.selectionKey);if(!e)return{};let t=JSON.parse(e);if(!t||typeof t!=`object`)return{};let n={};for(let[e,r]of Object.entries(t))w.has(e)&&typeof r==`string`&&r.length>0&&(n[e]=r);return n}catch(e){return i(`[butr] failed to parse selection from storage:`,e),{}}}async setSelection(e){try{let t={};for(let[n,r]of e)t[n]=r;await this.persistent.setItem(this.selectionKey,JSON.stringify(t))}catch(e){i(`[butr] failed to persist selection:`,e)}}async getActiveConnectorId(){try{let e=await this.persistent.getItem(this.activeKey);return e&&e.length>0?e:null}catch{return null}}async setActiveConnectorId(e){try{await(e===null?this.persistent.removeItem(this.activeKey):this.persistent.setItem(this.activeKey,e))}catch(e){i(`[butr] failed to persist active connector id:`,e)}}async clearAll(){await Promise.all([this.clearPool(),this.persistent.removeItem(this.selectionKey),this.persistent.removeItem(this.activeKey)])}async isUserDisconnected(){try{return await this.session.getItem(this.userDisconnectedKey)===`true`}catch{return!1}}async markUserDisconnected(e){try{await(e?this.session.setItem(this.userDisconnectedKey,`true`):this.session.removeItem(this.userDisconnectedKey))}catch{}}};const O=e=>{let t=new Map,n=e=>{let n=t.get(e);if(n){try{n()}catch(e){i(`[butr] unsubscribe threw:`,e)}t.delete(e)}};return{attach:(r,a)=>{if(a.subscribe){n(r);try{let i=a.subscribe(t=>{switch(t.type){case`accountChanged`:e.onAccountChanged(r,t.accounts,t.account);break;case`disconnected`:n(r),e.onDisconnected(r,a.chainPlatform);break;default:}});t.set(r,i)}catch(e){i(`[butr] subscribe failed for ${r}:`,e)}}},detach:n,detachAll:()=>{let e=[];for(let n of t.keys())e.push(n);for(let t of e)n(t)}}},k=async(e,t,n)=>{if(e.getAccounts){let t=await e.getAccounts().catch(()=>null);if(t&&t.length>0)return t}return t.length>0?[...t]:[n]},A=async(e,t,n)=>{try{await n.connect({silent:!0});let r=await n.getAccount()||t.account;return{connectorId:e,entry:{account:r,accounts:await k(n,t.accounts,r),connector:n},kind:`ok`}}catch(t){return{connectorId:e,error:t,kind:`fail`}}},j=(e,t)=>{let n=new Map;return{drainPending:async e=>{let r=n.get(e);if(!r)return null;let i=t(e);if(!i)return null;let a=await A(e,r,i);return n.delete(e),a},hydrate:async()=>{let[r,i,a,o]=await Promise.all([e.getPool(),e.getSelection(),e.getActiveConnectorId(),e.isUserDisconnected()]),s=new Map,c=[];n.clear();let l=[];for(let[e,i]of Object.entries(r)){if(!i)continue;let r=t(e);if(!r){n.set(e,i);continue}l.push(A(e,i,r))}let u=await Promise.all(l);for(let e of u){if(e.kind===`ok`){s.set(e.connectorId,e.entry);continue}c.push({connectorId:e.connectorId,reason:e.error})}let d=new Map;for(let[e,t]of Object.entries(i))t&&s.has(t)&&d.set(e,t);for(let[e,t]of s){let n=t.connector.chainPlatform;d.has(n)||d.set(n,e)}let f=null;return a&&s.has(a)?f=a:s.size>0&&(f=s.keys().next().value??null),{activeConnectorId:f,dropped:c,isUserDisconnected:o,pendingIds:[...n.keys()],pool:s,selection:d}},pendingIds:()=>[...n.keys()]}},M={activeConnectorId:null,connectingConnectorId:null,connectionError:null,connectionStatus:`idle`,isHydrated:!1,isUserDisconnected:!1,pool:new Map,reconnectingIds:new Set,selection:new Map},N=(e,t)=>{for(let[n,r]of e)if(r.connector.chainPlatform===t)return n},P=(e,t)=>{switch(t.type){case`HYDRATED`:{let n=new Map(e.pool);for(let[e,r]of t.pool)n.set(e,r);let r=new Map(e.selection);for(let[e,n]of t.selection)r.set(e,n);let i=null;t.activeConnectorId&&n.has(t.activeConnectorId)?i=t.activeConnectorId:e.activeConnectorId&&n.has(e.activeConnectorId)?i=e.activeConnectorId:n.size>0&&(i=n.keys().next().value??null);let a=e.reconnectingIds;if(e.reconnectingIds.size>0&&t.pool.size>0){let n=new Set(e.reconnectingIds);for(let e of t.pool.keys())n.delete(e);n.size!==e.reconnectingIds.size&&(a=n)}return{...e,activeConnectorId:i,isHydrated:!0,isUserDisconnected:t.isUserDisconnected,pool:n,reconnectingIds:a,selection:r}}case`USER_DISCONNECTED_SET`:return{...e,isUserDisconnected:t.value};case`CONNECT_STARTED`:return{...e,connectingConnectorId:t.connectorId,connectionError:null,connectionStatus:`connecting`};case`CONNECT_SUCCEEDED`:{let{connectorId:n,entry:r}=t,i=e.pool.get(n),a=e.reconnectingIds.has(n)?new Set([...e.reconnectingIds].filter(e=>e!==n)):e.reconnectingIds;if(i&&i.account.walletAddress.toLowerCase()===r.account.walletAddress.toLowerCase())return{...e,activeConnectorId:n,connectingConnectorId:null,connectionStatus:`success`,pool:i.connector===r.connector?e.pool:new Map([...e.pool,[n,r]]),reconnectingIds:a};let o=new Map([...e.pool,[n,r]]),s=new Map([...e.selection,[r.connector.chainPlatform,n]]);return{...e,activeConnectorId:n,connectingConnectorId:null,connectionStatus:`success`,pool:o,reconnectingIds:a,selection:s}}case`CONNECT_FAILED`:return{...e,connectingConnectorId:null,connectionError:t.error,connectionStatus:`error`};case`DISCONNECTED`:{let n=e.pool.get(t.connectorId);if(!n)return e;let r=new Map(e.pool);r.delete(t.connectorId);let i=new Map(e.selection),a=n.connector.chainPlatform;if(i.get(a)===t.connectorId){i.delete(a);let e=N(r,a);e&&i.set(a,e)}let o=r.keys().next(),s=e.activeConnectorId===t.connectorId?o.value??null:e.activeConnectorId,c=e.reconnectingIds.has(t.connectorId)?new Set([...e.reconnectingIds].filter(e=>e!==t.connectorId)):e.reconnectingIds;return{...e,activeConnectorId:s,pool:r,reconnectingIds:c,selection:i}}case`ACCOUNTS_REFRESHED`:{let n=e.pool.get(t.connectorId);if(!n)return e;let r;r=t.active?t.active:t.accounts.some(e=>e.walletAddress===n.account.walletAddress&&e.chain.id===n.account.chain.id)?n.account:t.accounts[0]??n.account;let i=r.walletAddress===n.account.walletAddress&&r.chain.id===n.account.chain.id,a=t.accounts.length===n.accounts.length&&t.accounts.every((e,t)=>e.walletAddress===n.accounts[t]?.walletAddress);if(i&&a)return e;let o={...n,account:r,accounts:[...t.accounts]},s=new Map([...e.pool,[t.connectorId,o]]);return{...e,pool:s}}case`WALLET_REFRESHED`:{let n=e.pool.get(t.connectorId);if(!n)return e;let r=new Map([...e.pool,[t.connectorId,{...n}]]);return{...e,pool:r}}case`ACTIVE_CHANGED`:return{...e,activeConnectorId:t.connectorId};case`SELECTION_CHANGED`:{let n=new Map(e.selection);return t.connectorId===null?n.delete(t.chainPlatform):n.set(t.chainPlatform,t.connectorId),{...e,selection:n}}case`STATUS_RESET`:return{...e,connectingConnectorId:null,connectionError:null,connectionStatus:`idle`};case`ERROR_SET`:return{...e,connectionError:t.error,connectionStatus:t.error?`error`:`idle`};case`RESET`:return{...M,isHydrated:e.isHydrated,isUserDisconnected:!0,reconnectingIds:new Set};default:return e}};var F=class extends Error{code=`BUTR_RECONNECTING`;connectorId;method;constructor(e,t){super(`[butr] ${e} called on shadow connector "${t}" — wait for silent reconnect to complete (check reconnectingIds.has(id) before calling).`),this.name=`ShadowConnectorError`,this.connectorId=t,this.method=e}};const I=Object.freeze({getBalance:!1,getTransactionReceipt:!1,requestAccounts:!1,sendTransaction:!1,signIn:!1,signMessage:!1,signTransaction:!1,subscribe:!1,switchAccount:!1,switchChain:!1}),L=e=>{let t=e.connectorId,n=e.name,r=e.icon,i=e=>Promise.reject(new F(e,t)),a={capabilities:I,connect:()=>i(`connect`),disconnect:()=>i(`disconnect`),getAccount:()=>i(`getAccount`),getBalance:()=>i(`getBalance`),getSigner:()=>i(`getSigner`),getTransactionReceipt:()=>i(`getTransactionReceipt`),icon:r,id:t,name:n,sendTx:()=>i(`sendTx`),sendTxToChain:()=>i(`sendTxToChain`),signMessage:()=>i(`signMessage`),switchChain:()=>i(`switchChain`)};switch(e.chainPlatform){case`bitcoin`:return{...a,chainPlatform:`bitcoin`};case`evm`:return{...a,chainPlatform:`evm`};case`sui`:return{...a,chainPlatform:`sui`};case`svm`:return{...a,chainPlatform:`svm`};case`polkadot`:return{...a,chainPlatform:`polkadot`};default:throw e.chainPlatform,Error(`[butr] unknown chainPlatform: ${e.chainPlatform}`)}},R=async(e,t)=>{try{await e()}catch(e){t(e)}},z=e=>{let t=new Map,n=new Set;for(let[r,i]of Object.entries(e.pool)){if(!i)continue;let e=L(i);t.set(r,{account:i.account,accounts:[...i.accounts],connector:e}),n.add(r)}let r=new Map;for(let[n,i]of Object.entries(e.selection))i&&t.has(i)&&r.set(n,i);let i=e.activeConnectorId&&t.has(e.activeConnectorId)?e.activeConnectorId:t.keys().next().value??null;return{...M,activeConnectorId:i,isHydrated:!0,pool:t,reconnectingIds:n,selection:r}},B=e=>e.toLowerCase(),V=t=>{let r=t.storageKeyPrefix||`butr`,o=t.storage||new D({keyPrefix:r}),s=e=>n=>{if(t.onStorageError){try{t.onStorageError(n,e)}catch(e){i(`[butr] onStorageError threw:`,e)}return}i(`[butr] ${e}:`,n)},c=j(o,t.createConnector);return e()((e,r)=>{let l=t=>{e(e=>P(e,t),!1)},u=()=>R(()=>o.setPool(r().pool),s(`failed to persist pool`)),d=()=>R(()=>o.setSelection(r().selection),s(`failed to persist selection`)),f=()=>R(()=>o.setActiveConnectorId(r().activeConnectorId),s(`failed to persist active connector`)),p=(e,t,n)=>{l({accounts:t,active:n,connectorId:e,type:`ACCOUNTS_REFRESHED`}),u()},m=O({onAccountChanged:(e,t,n)=>{p(e,[...t],n)},onDisconnected:(e,n)=>{l({connectorId:e,type:`DISCONNECTED`}),t.onDisconnect?.(n)}});return{...t.initialState?z(t.initialState):M,_config:t,_storage:o,connectWallet:async(e,a,o)=>{r().setUserDisconnected(!1);let s=t.createConnector(e);if(!s)throw Error(`Failed to create connector for ${e}`);l({connectorId:e,type:`CONNECT_STARTED`});let c=t.slowConnectThresholdMs??5e3,p=t.onSlowConnect?setTimeout(()=>{try{t.onSlowConnect?.(e)}catch(e){i(`[butr] onSlowConnect threw:`,e)}},c):null;try{let n=s.connect();n.catch(()=>{}),await Promise.race([n,new Promise((e,t)=>{setTimeout(()=>{t(Error(`Connection timeout`))},9e4)})]);let r=await s.getAccount();if(!r)throw Error(`Failed to get account`);let i=s.getAccounts?await s.getAccounts().catch(()=>null):null,o={account:r,accounts:i&&i.length>0?i:[r],connector:s};l({connectorId:e,entry:o,type:`CONNECT_SUCCEEDED`}),m.attach(e,s),await Promise.all([u(),d(),f()]),t.onConnect?.(o),a?.(o)}catch(r){let a=n(r);l({error:a,type:`CONNECT_FAILED`});try{await s.disconnect?.()}catch(e){i(`[butr] disconnect during error recovery failed:`,e)}try{t.onConnectError?.(a,e)}catch(e){i(`[butr] onConnectError threw:`,e)}throw o?.(r),r}finally{p&&clearTimeout(p)}},disconnectWallet:e=>{r().setUserDisconnected(!0);let n=r();if(!n.isHydrated)return;let i=n.pool.get(e);if(!i)return;m.detach(e),R(()=>i.connector.disconnect?.()??Promise.resolve(),a);let c=i.connector.chainPlatform;l({connectorId:e,type:`DISCONNECTED`}),r().pool.size===0?R(()=>o.clearAll(),s(`failed to clear storage`)):(R(()=>o.removePoolEntry(e),s(`failed to remove pool entry`)),d(),f()),t.onDisconnect?.(c)},getConnectorInstance:e=>t.createConnector(e),hydrateWallets:async()=>{let e=await c.hydrate();l({activeConnectorId:e.activeConnectorId,isUserDisconnected:e.isUserDisconnected,pool:e.pool,selection:e.selection,type:`HYDRATED`});for(let[t,n]of e.pool)m.attach(t,n.connector);if(await Promise.all([d(),f()]),Promise.all(c.pendingIds().map(e=>r().tryRestoreFromPending(e))),t.onHydrated)try{t.onHydrated({dropped:e.dropped,pendingIds:[...e.pendingIds],restoredIds:[...e.pool.keys()]})}catch(e){i(`[butr] onHydrated threw:`,e)}else if(e.dropped.length>0)for(let{connectorId:t,reason:n}of e.dropped)i(`[butr] failed to restore connector ${t}:`,n)},refreshWallet:e=>{l({connectorId:e,type:`WALLET_REFRESHED`})},requestAccounts:async e=>{let t=r().pool.get(e);if(!t)return;await t.connector.requestAccounts?.();let n=t.connector.getAccounts?await t.connector.getAccounts().catch(()=>null):null;!n||n.length===0||p(e,n)},reset:()=>{r().setUserDisconnected(!0);let e=r();if(e.isHydrated){m.detachAll();for(let t of e.pool.values())R(()=>t.connector.disconnect?.()??Promise.resolve(),a);if(R(()=>o.clearAll(),s(`failed to clear storage`)),t.onReset){let e=t.onReset;R(()=>Promise.resolve(e()),a)}l({type:`RESET`})}},resetConnectionStatus:()=>{l({type:`STATUS_RESET`})},setActiveConnector:e=>{l({connectorId:e,type:`ACTIVE_CHANGED`}),f()},setConnectionError:e=>{l({error:e,type:`ERROR_SET`})},setSelection:(e,t)=>{l({chainPlatform:e,connectorId:t,type:`SELECTION_CHANGED`}),d()},setUserDisconnected:e=>{l({type:`USER_DISCONNECTED_SET`,value:e}),R(()=>o.markUserDisconnected(e),s(`failed to persist disconnect intent`))},tryRestoreFromPending:async e=>{let n=await c.drainPending(e);if(n){if(n.kind===`fail`){i(`[butr] late restore failed for ${e}:`,n.error);return}l({connectorId:e,entry:n.entry,type:`CONNECT_SUCCEEDED`}),m.attach(e,n.entry.connector),await Promise.all([u(),d(),f()]),t.onConnect?.(n.entry)}},updateWalletAccount:(e,t)=>{let n=r().pool.get(e);if(!n)return;let i=t.chain,a=n.accounts.map(e=>e.chain.id===i.id?e:{chain:i,id:`${i.id}:${B(e.walletAddress)}`,walletAddress:e.walletAddress});p(e,a.some(e=>B(e.walletAddress)===B(t.walletAddress))?a:[...a,t],t)}}})},H=(e,t)=>e===t?!0:!e||!t?!1:e.connector.id===t.connector.id&&e.account.walletAddress===t.account.walletAddress&&e.account.chain.id===t.account.chain.id,U=e=>{if(e===void 0)return;let t=e.trim();return t.length>0?t:void 0};export{_ as EMPTY_SNAPSHOT,D as WalletStorage,t as buildChainsByPlatform,l as createBrowserStorageDriver,h as createCookieStorageDriver,s as createMemoryStorageDriver,r as createWalletSource,V as createWalletStore,a as logError,i as logWarn,n as mapConnectionError,C as readWalletSnapshot,U as sanitizeIcon,H as walletEqual};
+import { createStore } from "zustand/vanilla";
+
+//#region src/types/chains-by-platform.ts
+/**
+* Build a fully-populated `ChainsByPlatform` from a partial. Platforms
+* the consumer doesn't specify default to an empty list.
+*
+* Use this in apps that target one or two chain platforms — importing
+* only those packages keeps unused chain registries out of the bundle.
+* Apps that want every chain reach for `CHAINS_BY_PLATFORM` from
+* `@usebutr/wallets` instead.
+*
+* @example
+* // EVM-only app — Solana/Sui/Bitcoin tables never enter the bundle
+* import { EVM_CHAINS_LIST } from "@usebutr/evm";
+* import { buildChainsByPlatform } from "@usebutr/core";
+*
+* const chains = buildChainsByPlatform({ evm: EVM_CHAINS_LIST });
+*
+* @example
+* // Multi-chain app — pull from each package the app actually uses
+* import { EVM_CHAINS_LIST } from "@usebutr/evm";
+* import { SVM_CHAINS_LIST } from "@usebutr/svm";
+*
+* const chains = buildChainsByPlatform({
+*   evm: EVM_CHAINS_LIST,
+*   svm: SVM_CHAINS_LIST,
+* });
+*/
+const buildChainsByPlatform = (partial) => ({
+	bitcoin: partial.bitcoin ?? [],
+	evm: partial.evm ?? [],
+	polkadot: partial.polkadot ?? [],
+	sui: partial.sui ?? [],
+	svm: partial.svm ?? []
+});
+
+//#endregion
+//#region src/types/errors.ts
+/**
+* Normalise a thrown value into a `ConnectionError`.
+*
+* Recognises:
+*  - butr's own `Error("Connection timeout")` (from the 90s connect timeout)
+*  - butr's own `Error("Failed to get account")` (from the connect flow)
+*  - EIP-1193 numeric `code` properties (`4001` → UserRejected,
+*    `-32002` → RequestPending, `4100`/`4900`/`4901` → NotConnected —
+*    unauthorized / disconnected from all-or-one chains)
+*  - common message substrings: "user rejected" / "user denied",
+*    "locked", "chain", etc.
+*  - anything else → `Unknown` with `cause` set to the original value.
+*/
+const mapConnectionError = (raw) => {
+	if (raw instanceof Error) {
+		const message = raw.message;
+		const lower = message.toLowerCase();
+		if (message === "Connection timeout") return {
+			kind: "Timeout",
+			message
+		};
+		if (message === "Failed to get account" || lower.includes("not connected")) return {
+			kind: "NotConnected",
+			message
+		};
+		const code = raw.code;
+		if (code === 4001) return {
+			kind: "UserRejected",
+			message
+		};
+		if (code === -32002) return {
+			kind: "RequestPending",
+			message
+		};
+		if (code === 4100 || code === 4900 || code === 4901) return {
+			kind: "NotConnected",
+			message
+		};
+		if (lower.includes("user rejected") || lower.includes("user denied")) return {
+			kind: "UserRejected",
+			message
+		};
+		if (lower.includes("locked")) return {
+			kind: "WalletLocked",
+			message
+		};
+		if (lower.includes("chain") && (lower.includes("mismatch") || lower.includes("unsupported"))) return {
+			kind: "ChainMismatch",
+			message
+		};
+		return {
+			cause: raw,
+			kind: "Unknown",
+			message
+		};
+	}
+	if (typeof raw === "string") return {
+		kind: "Unknown",
+		message: raw
+	};
+	return {
+		cause: raw,
+		kind: "Unknown",
+		message: "Connection failed"
+	};
+};
+
+//#endregion
+//#region src/types/wallet.ts
+/**
+* Canonical list of supported chain platforms. The single runtime source
+* of truth: `ChainPlatform` is derived from it, and storage validators
+* build their allowlists from it, so the type and the runtime checks can
+* never drift (a missing platform here was why Polkadot connections failed
+* to persist).
+*/
+const CHAIN_PLATFORMS = [
+	"evm",
+	"svm",
+	"sui",
+	"bitcoin",
+	"polkadot"
+];
+
+//#endregion
+//#region src/wallet-source.ts
+/**
+* Wrap a bare `subscribe` function (the exact shape of
+* `discoverEvmAdapters` / `discoverSvmAdapters`) into a `WalletSource`,
+* so an EVM-only app can do
+* `createWalletSource(discoverEvmAdapters)` without importing anything
+* protocol-bearing beyond `@usebutr/evm`.
+*/
+const createWalletSource = (subscribe) => ({ subscribe });
+
+//#endregion
+//#region src/logger.ts
+const logWarn = (...args) => {
+	console.warn(...args);
+};
+const logError = (...args) => {
+	console.error(...args);
+};
+
+//#endregion
+//#region src/storage/browser-storage-driver.ts
+const hasWebStorage = (kind) => {
+	try {
+		return typeof globalThis !== "undefined" && globalThis[kind] !== void 0;
+	} catch {
+		return false;
+	}
+};
+const createMemoryStorageDriver = () => {
+	const memory = /* @__PURE__ */ new Map();
+	return {
+		getItem(key) {
+			return memory.get(key) ?? null;
+		},
+		removeItem(key) {
+			memory.delete(key);
+		},
+		setItem(key, value) {
+			memory.set(key, value);
+		}
+	};
+};
+const createWebStorageDriver = (kind) => {
+	if (!hasWebStorage(kind)) return createMemoryStorageDriver();
+	const storage = globalThis[kind];
+	return {
+		getItem(key) {
+			try {
+				return storage.getItem(key);
+			} catch {
+				return null;
+			}
+		},
+		removeItem(key) {
+			try {
+				storage.removeItem(key);
+			} catch {}
+		},
+		setItem(key, value) {
+			try {
+				storage.setItem(key, value);
+			} catch {}
+		}
+	};
+};
+/**
+* Default storage drivers for web. `persistent` wraps `localStorage`,
+* `session` wraps `sessionStorage`. Both fall back to in-memory maps
+* when the global isn't available (SSR, non-browser environments).
+*/
+const createBrowserStorageDriver = () => ({
+	persistent: createWebStorageDriver("localStorage"),
+	session: createWebStorageDriver("sessionStorage")
+});
+
+//#endregion
+//#region src/storage/wallet-storage.ts
+const VALID_CHAIN_PLATFORMS$1 = new Set(CHAIN_PLATFORMS);
+const isValidAccount$1 = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const account = value;
+	if (typeof account.walletAddress !== "string" || typeof account.id !== "string") return false;
+	if (!account.chain || typeof account.chain !== "object") return false;
+	return true;
+};
+/**
+* Structural validator for a serialized pool entry.
+*
+* Used in two directions:
+*  - On read (`getPool`): malformed entries from storage are warned
+*    and dropped — legacy / cross-tab corruption shouldn't crash the
+*    consumer.
+*  - On write (`setPool`): the runtime's reducer state is the source
+*    of truth, and a malformed write would indicate a programming
+*    error inside butr. Throw rather than silently corrupt storage.
+*
+* Same validator either way — keeping the two paths symmetric means
+* "what's storable" is a single fact.
+*/
+const isValidPoolEntry$1 = (key, value) => {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	if (typeof entry.connectorId !== "string" || entry.connectorId !== key) return false;
+	if (typeof entry.chainPlatform !== "string") return false;
+	if (!VALID_CHAIN_PLATFORMS$1.has(entry.chainPlatform)) return false;
+	if (typeof entry.name !== "string" || entry.name.length === 0) return false;
+	if (entry.icon !== void 0 && typeof entry.icon !== "string") return false;
+	if (!isValidAccount$1(entry.account)) return false;
+	if (!Array.isArray(entry.accounts) || !entry.accounts.every(isValidAccount$1)) return false;
+	return true;
+};
+var WalletStorage = class {
+	poolKey;
+	selectionKey;
+	activeKey;
+	userDisconnectedKey;
+	persistent;
+	session;
+	/**
+	* Serializes pool-key mutations so concurrent fire-and-forget
+	* writes can't interleave their read-modify-write phases. Without
+	* this, two simultaneous `setPool` calls both read the pre-write
+	* state, each merge their own entries, and whichever finishes last
+	* overwrites the other's additions. Reads (`getPool`) don't enter
+	* the queue — they observe whatever's currently in the driver.
+	*/
+	poolMutationQueue = Promise.resolve();
+	constructor(config) {
+		this.poolKey = `${config.keyPrefix}-pool`;
+		this.selectionKey = `${config.keyPrefix}-selection`;
+		this.activeKey = `${config.keyPrefix}-active`;
+		this.userDisconnectedKey = `${config.keyPrefix}-user-disconnected`;
+		if (config.persistent && config.session) {
+			this.persistent = config.persistent;
+			this.session = config.session;
+		} else {
+			const defaults = createBrowserStorageDriver();
+			this.persistent = config.persistent ?? defaults.persistent;
+			this.session = config.session ?? defaults.session;
+		}
+	}
+	/** Chain `fn` after the in-flight pool mutation. */
+	async serializePoolMutation(fn) {
+		const previous = this.poolMutationQueue;
+		let resolve = () => {};
+		this.poolMutationQueue = new Promise((r) => {
+			resolve = r;
+		});
+		try {
+			await previous;
+		} catch {}
+		try {
+			return await fn();
+		} finally {
+			resolve();
+		}
+	}
+	async getPool() {
+		try {
+			const stored = await this.persistent.getItem(this.poolKey);
+			if (!stored) return {};
+			const parsed = JSON.parse(stored);
+			if (!parsed || typeof parsed !== "object") {
+				await this.clearPool();
+				return {};
+			}
+			const result = {};
+			for (const [key, value] of Object.entries(parsed)) if (isValidPoolEntry$1(key, value)) result[key] = value;
+			else logWarn(`[butr] dropping invalid pool entry for ${key}`);
+			return result;
+		} catch (error) {
+			logWarn("[butr] failed to parse pool from storage:", error);
+			await this.clearPool();
+			return {};
+		}
+	}
+	/**
+	* Upsert the in-memory pool into storage. Additive: entries in
+	* `pool` are written; entries already in storage that aren't in
+	* `pool` are kept. The in-memory pool reflects "what's live right
+	* now", not "the complete list of remembered connections" — a
+	* silent reconnect that fails on reload leaves the entry out of
+	* the pool but the saved entry stays so the next load can retry.
+	* Use `removePoolEntry` for explicit eviction (the user clicked
+	* Disconnect) and `clearAll` for a full wipe (reset).
+	*/
+	setPool(pool) {
+		return this.serializePoolMutation(async () => {
+			try {
+				const serializable = { ...await this.getPool() };
+				for (const [connectorId, wallet] of pool) {
+					const entry = {
+						account: wallet.account,
+						accounts: wallet.accounts,
+						chainPlatform: wallet.connector.chainPlatform,
+						connectorId,
+						icon: wallet.connector.icon,
+						name: wallet.connector.name
+					};
+					if (!isValidPoolEntry$1(connectorId, entry)) throw new Error(`[butr] refusing to persist invalid pool entry for ${connectorId}`);
+					serializable[connectorId] = entry;
+				}
+				await this.persistent.setItem(this.poolKey, JSON.stringify(serializable));
+			} catch (error) {
+				logWarn("[butr] failed to persist pool:", error);
+			}
+		});
+	}
+	removePoolEntry(connectorId) {
+		return this.serializePoolMutation(async () => {
+			try {
+				const stored = await this.getPool();
+				if (stored[connectorId]) {
+					const { [connectorId]: _, ...remaining } = stored;
+					await this.persistent.setItem(this.poolKey, JSON.stringify(remaining));
+				}
+			} catch (error) {
+				logWarn(`[butr] failed to remove pool entry ${connectorId}:`, error);
+			}
+		});
+	}
+	clearPool() {
+		return this.serializePoolMutation(async () => {
+			await this.persistent.removeItem(this.poolKey);
+		});
+	}
+	async getSelection() {
+		try {
+			const stored = await this.persistent.getItem(this.selectionKey);
+			if (!stored) return {};
+			const parsed = JSON.parse(stored);
+			if (!parsed || typeof parsed !== "object") return {};
+			const result = {};
+			for (const [key, value] of Object.entries(parsed)) if (VALID_CHAIN_PLATFORMS$1.has(key) && typeof value === "string" && value.length > 0) result[key] = value;
+			return result;
+		} catch (error) {
+			logWarn("[butr] failed to parse selection from storage:", error);
+			return {};
+		}
+	}
+	async setSelection(selection) {
+		try {
+			const serializable = {};
+			for (const [platform, connectorId] of selection) serializable[platform] = connectorId;
+			await this.persistent.setItem(this.selectionKey, JSON.stringify(serializable));
+		} catch (error) {
+			logWarn("[butr] failed to persist selection:", error);
+		}
+	}
+	async getActiveConnectorId() {
+		try {
+			const value = await this.persistent.getItem(this.activeKey);
+			return value && value.length > 0 ? value : null;
+		} catch {
+			return null;
+		}
+	}
+	async setActiveConnectorId(connectorId) {
+		try {
+			await (connectorId === null ? this.persistent.removeItem(this.activeKey) : this.persistent.setItem(this.activeKey, connectorId));
+		} catch (error) {
+			logWarn("[butr] failed to persist active connector id:", error);
+		}
+	}
+	async clearAll() {
+		await Promise.all([
+			this.clearPool(),
+			this.persistent.removeItem(this.selectionKey),
+			this.persistent.removeItem(this.activeKey)
+		]);
+	}
+	/**
+	* Disconnect-intent tracking.
+	*
+	* Lives in the session driver: survives component remounts (unlike refs)
+	* but clears when the session ends (unlike the persistent driver).
+	* Prevents auto-connect from firing immediately after a manual disconnect,
+	* while still allowing auto-connect on fresh sessions.
+	*/
+	async isUserDisconnected() {
+		try {
+			return await this.session.getItem(this.userDisconnectedKey) === "true";
+		} catch {
+			return false;
+		}
+	}
+	async markUserDisconnected(value) {
+		try {
+			await (value ? this.session.setItem(this.userDisconnectedKey, "true") : this.session.removeItem(this.userDisconnectedKey));
+		} catch {}
+	}
+};
+
+//#endregion
+//#region src/store/connector-lifecycle.ts
+const createConnectorLifecycle = (handlers) => {
+	const unsubscribers = /* @__PURE__ */ new Map();
+	const detach = (connectorId) => {
+		const unsub = unsubscribers.get(connectorId);
+		if (!unsub) return;
+		try {
+			unsub();
+		} catch (error) {
+			logWarn("[butr] unsubscribe threw:", error);
+		}
+		unsubscribers.delete(connectorId);
+	};
+	return {
+		attach: (connectorId, connector) => {
+			if (!connector.subscribe) return;
+			detach(connectorId);
+			try {
+				const unsub = connector.subscribe((event) => {
+					switch (event.type) {
+						case "accountChanged":
+							handlers.onAccountChanged(connectorId, event.accounts, event.account);
+							break;
+						case "disconnected":
+							detach(connectorId);
+							handlers.onDisconnected(connectorId, connector.chainPlatform);
+							break;
+						default:
+					}
+				});
+				unsubscribers.set(connectorId, unsub);
+			} catch (error) {
+				logWarn(`[butr] subscribe failed for ${connectorId}:`, error);
+			}
+		},
+		detach,
+		detachAll: () => {
+			const ids = [];
+			for (const id of unsubscribers.keys()) ids.push(id);
+			for (const id of ids) detach(id);
+		}
+	};
+};
+
+//#endregion
+//#region src/store/hydration.ts
+/** Pick the right `accounts` list: fresh from the connector if it
+*  exposes `getAccounts`, otherwise the persisted list, otherwise just
+*  the active account. */
+const resolveHydratedAccounts = async (connector, storedAccounts, fallbackAccount) => {
+	if (connector.getAccounts) {
+		const fresh = await connector.getAccounts().catch(() => null);
+		if (fresh && fresh.length > 0) return fresh;
+	}
+	if (storedAccounts.length > 0) return [...storedAccounts];
+	return [fallbackAccount];
+};
+const restoreOneEntry = async (connectorId, entry, connector) => {
+	try {
+		await connector.connect({ silent: true });
+		const accountToUse = await connector.getAccount() || entry.account;
+		return {
+			connectorId,
+			entry: {
+				account: accountToUse,
+				accounts: await resolveHydratedAccounts(connector, entry.accounts, accountToUse),
+				connector
+			},
+			kind: "ok"
+		};
+	} catch (error) {
+		return {
+			connectorId,
+			error,
+			kind: "fail"
+		};
+	}
+};
+const createHydrationCoordinator = (storage, createConnector) => {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		drainPending: async (connectorId) => {
+			const entry = pending.get(connectorId);
+			if (!entry) return null;
+			const connector = createConnector(connectorId);
+			if (!connector) return null;
+			const outcome = await restoreOneEntry(connectorId, entry, connector);
+			pending.delete(connectorId);
+			return outcome;
+		},
+		hydrate: async () => {
+			const [storedPool, storedSelection, storedActive, userDisconnected] = await Promise.all([
+				storage.getPool(),
+				storage.getSelection(),
+				storage.getActiveConnectorId(),
+				storage.isUserDisconnected()
+			]);
+			const pool = /* @__PURE__ */ new Map();
+			const dropped = [];
+			pending.clear();
+			const tasks = [];
+			for (const [connectorId, entry] of Object.entries(storedPool)) {
+				if (!entry) continue;
+				const connector = createConnector(connectorId);
+				if (!connector) {
+					pending.set(connectorId, entry);
+					continue;
+				}
+				tasks.push(restoreOneEntry(connectorId, entry, connector));
+			}
+			const outcomes = await Promise.all(tasks);
+			for (const outcome of outcomes) {
+				if (outcome.kind === "ok") {
+					pool.set(outcome.connectorId, outcome.entry);
+					continue;
+				}
+				dropped.push({
+					connectorId: outcome.connectorId,
+					reason: outcome.error
+				});
+			}
+			const selection = /* @__PURE__ */ new Map();
+			for (const [platform, connectorId] of Object.entries(storedSelection)) if (connectorId && pool.has(connectorId)) selection.set(platform, connectorId);
+			for (const [connectorId, wallet] of pool) {
+				const platform = wallet.connector.chainPlatform;
+				if (!selection.has(platform)) selection.set(platform, connectorId);
+			}
+			let activeConnectorId = null;
+			if (storedActive && pool.has(storedActive)) activeConnectorId = storedActive;
+			else if (pool.size > 0) activeConnectorId = pool.keys().next().value ?? null;
+			return {
+				activeConnectorId,
+				dropped,
+				isUserDisconnected: userDisconnected,
+				pendingIds: [...pending.keys()],
+				pool,
+				selection
+			};
+		},
+		pendingIds: () => [...pending.keys()]
+	};
+};
+
+//#endregion
+//#region src/store/reducer.ts
+const initialState = {
+	activeConnectorId: null,
+	connectingConnectorId: null,
+	connectionError: null,
+	connectionStatus: "idle",
+	isHydrated: false,
+	isUserDisconnected: false,
+	pool: /* @__PURE__ */ new Map(),
+	reconnectingIds: /* @__PURE__ */ new Set(),
+	selection: /* @__PURE__ */ new Map()
+};
+/** Find any connector in the pool serving a given platform. */
+const findConnectorForPlatform = (pool, chainPlatform) => {
+	for (const [id, wallet] of pool) if (wallet.connector.chainPlatform === chainPlatform) return id;
+};
+/** Pure reducer: every state transition is expressed as `(state, event) => state`.
+*  No I/O, no async, no side effects. Side effects live in the runtime. */
+const reducer = (state, event) => {
+	switch (event.type) {
+		case "HYDRATED": {
+			const pool = new Map(state.pool);
+			for (const [id, entry] of event.pool) pool.set(id, entry);
+			const selection = new Map(state.selection);
+			for (const [platform, id] of event.selection) selection.set(platform, id);
+			let activeConnectorId = null;
+			if (event.activeConnectorId && pool.has(event.activeConnectorId)) activeConnectorId = event.activeConnectorId;
+			else if (state.activeConnectorId && pool.has(state.activeConnectorId)) activeConnectorId = state.activeConnectorId;
+			else if (pool.size > 0) activeConnectorId = pool.keys().next().value ?? null;
+			let nextReconnecting = state.reconnectingIds;
+			if (state.reconnectingIds.size > 0 && event.pool.size > 0) {
+				const next = new Set(state.reconnectingIds);
+				for (const id of event.pool.keys()) next.delete(id);
+				if (next.size !== state.reconnectingIds.size) nextReconnecting = next;
+			}
+			return {
+				...state,
+				activeConnectorId,
+				isHydrated: true,
+				isUserDisconnected: event.isUserDisconnected,
+				pool,
+				reconnectingIds: nextReconnecting,
+				selection
+			};
+		}
+		case "USER_DISCONNECTED_SET": return {
+			...state,
+			isUserDisconnected: event.value
+		};
+		case "CONNECT_STARTED": return {
+			...state,
+			connectingConnectorId: event.connectorId,
+			connectionError: null,
+			connectionStatus: "connecting"
+		};
+		case "CONNECT_SUCCEEDED": {
+			const { connectorId, entry } = event;
+			const existing = state.pool.get(connectorId);
+			const nextReconnecting = state.reconnectingIds.has(connectorId) ? new Set([...state.reconnectingIds].filter((id) => id !== connectorId)) : state.reconnectingIds;
+			if (existing && existing.account.walletAddress.toLowerCase() === entry.account.walletAddress.toLowerCase()) return {
+				...state,
+				activeConnectorId: connectorId,
+				connectingConnectorId: null,
+				connectionStatus: "success",
+				pool: existing.connector === entry.connector ? state.pool : new Map([...state.pool, [connectorId, entry]]),
+				reconnectingIds: nextReconnecting
+			};
+			const newPool = new Map([...state.pool, [connectorId, entry]]);
+			const newSelection = new Map([...state.selection, [entry.connector.chainPlatform, connectorId]]);
+			return {
+				...state,
+				activeConnectorId: connectorId,
+				connectingConnectorId: null,
+				connectionStatus: "success",
+				pool: newPool,
+				reconnectingIds: nextReconnecting,
+				selection: newSelection
+			};
+		}
+		case "CONNECT_FAILED": return {
+			...state,
+			connectingConnectorId: null,
+			connectionError: event.error,
+			connectionStatus: "error"
+		};
+		case "DISCONNECTED": {
+			const wallet = state.pool.get(event.connectorId);
+			if (!wallet) return state;
+			const newPool = new Map(state.pool);
+			newPool.delete(event.connectorId);
+			const newSelection = new Map(state.selection);
+			const platform = wallet.connector.chainPlatform;
+			if (newSelection.get(platform) === event.connectorId) {
+				newSelection.delete(platform);
+				const fallback = findConnectorForPlatform(newPool, platform);
+				if (fallback) newSelection.set(platform, fallback);
+			}
+			const firstId = newPool.keys().next();
+			const activeConnectorId = state.activeConnectorId === event.connectorId ? firstId.value ?? null : state.activeConnectorId;
+			const nextReconnecting = state.reconnectingIds.has(event.connectorId) ? new Set([...state.reconnectingIds].filter((id) => id !== event.connectorId)) : state.reconnectingIds;
+			return {
+				...state,
+				activeConnectorId,
+				pool: newPool,
+				reconnectingIds: nextReconnecting,
+				selection: newSelection
+			};
+		}
+		case "ACCOUNTS_REFRESHED": {
+			const wallet = state.pool.get(event.connectorId);
+			if (!wallet) return state;
+			let nextAccount;
+			if (event.active) nextAccount = event.active;
+			else nextAccount = event.accounts.some((a) => a.walletAddress === wallet.account.walletAddress && a.chain.id === wallet.account.chain.id) ? wallet.account : event.accounts[0] ?? wallet.account;
+			const sameAccount = nextAccount.walletAddress === wallet.account.walletAddress && nextAccount.chain.id === wallet.account.chain.id;
+			const sameAccountsShape = event.accounts.length === wallet.accounts.length && event.accounts.every((a, i) => a.walletAddress === wallet.accounts[i]?.walletAddress);
+			if (sameAccount && sameAccountsShape) return state;
+			const updated = {
+				...wallet,
+				account: nextAccount,
+				accounts: [...event.accounts]
+			};
+			const newPool = new Map([...state.pool, [event.connectorId, updated]]);
+			return {
+				...state,
+				pool: newPool
+			};
+		}
+		case "WALLET_REFRESHED": {
+			const wallet = state.pool.get(event.connectorId);
+			if (!wallet) return state;
+			const newPool = new Map([...state.pool, [event.connectorId, { ...wallet }]]);
+			return {
+				...state,
+				pool: newPool
+			};
+		}
+		case "ACTIVE_CHANGED": return {
+			...state,
+			activeConnectorId: event.connectorId
+		};
+		case "SELECTION_CHANGED": {
+			const newSelection = new Map(state.selection);
+			if (event.connectorId === null) newSelection.delete(event.chainPlatform);
+			else newSelection.set(event.chainPlatform, event.connectorId);
+			return {
+				...state,
+				selection: newSelection
+			};
+		}
+		case "STATUS_RESET": return {
+			...state,
+			connectingConnectorId: null,
+			connectionError: null,
+			connectionStatus: "idle"
+		};
+		case "ERROR_SET": return {
+			...state,
+			connectionError: event.error,
+			connectionStatus: event.error ? "error" : "idle"
+		};
+		case "RESET": return {
+			...initialState,
+			isHydrated: state.isHydrated,
+			isUserDisconnected: true,
+			reconnectingIds: /* @__PURE__ */ new Set()
+		};
+		default: return state;
+	}
+};
+
+//#endregion
+//#region src/store/shadow-adapter.ts
+/**
+* Error thrown when a method is called on a shadow adapter — the
+* placeholder `WalletAdapter` that the store seeds into the pool when
+* an `initialState` is provided (e.g. from a server-rendered cookie
+* snapshot). Shadow adapters carry the identity and account data of a
+* previously-connected wallet, but the live wallet extension hasn't
+* been verified yet — the silent reconnect happens asynchronously
+* after mount.
+*
+* UI code that gates affordances on `wallet.connector.capabilities.*`
+* never reaches a shadow method (capabilities are all `false`). Code
+* that calls through anyway hits this typed error, which is the
+* correct loud failure: the consumer ignored the capability gate.
+*
+* Consumers wanting to wait out the reconnecting window should branch
+* on whether `connectorId` is in `state.reconnectingIds`.
+*/
+var ShadowConnectorError = class extends Error {
+	code = "BUTR_RECONNECTING";
+	connectorId;
+	method;
+	constructor(method, connectorId) {
+		super(`[butr] ${method} called on shadow connector "${connectorId}" — wait for silent reconnect to complete (check reconnectingIds.has(id) before calling).`);
+		this.name = "ShadowConnectorError";
+		this.connectorId = connectorId;
+		this.method = method;
+	}
+};
+const ALL_FALSE_CAPABILITIES = Object.freeze({
+	getBalance: false,
+	getTransactionReceipt: false,
+	requestAccounts: false,
+	sendTransaction: false,
+	signIn: false,
+	signMessage: false,
+	signTransaction: false,
+	subscribe: false,
+	switchAccount: false,
+	switchChain: false
+});
+/**
+* Builds a placeholder `WalletAdapter` from a persisted pool entry.
+*
+* Used by `createWalletStore` when `WalletManagerConfig.initialState`
+* is provided: each stored entry becomes a `ConnectedWallet` whose
+* `connector` is one of these. The store flips `isHydrated` true
+* synchronously and exposes the data through the usual hooks
+* (`useActiveWallet`, `useConnectedWallets`, …) — but the connector
+* can't actually talk to a wallet yet, so its capabilities are all
+* `false` and its methods throw `ShadowConnectorError` if called.
+*
+* The hydration coordinator's silent-reconnect pass upgrades each
+* shadow to a live `WalletAdapter` by calling `createConnector(id)`
+* (which only succeeds once the live adapter has been announced via
+* discovery or registered explicitly) and replacing the pool entry.
+* On success the connector id is removed from `reconnectingIds`; on
+* failure the entry is dropped from the pool and storage.
+*
+* The entry's `name` is required (the storage validator rejects
+* entries without it); `icon` is optional only because some live
+* adapters genuinely have no icon to begin with.
+*/
+const createShadowAdapter = (entry) => {
+	const id = entry.connectorId;
+	const name = entry.name;
+	const icon = entry.icon;
+	const reject = (method) => Promise.reject(new ShadowConnectorError(method, id));
+	const base = {
+		capabilities: ALL_FALSE_CAPABILITIES,
+		connect: () => reject("connect"),
+		disconnect: () => reject("disconnect"),
+		getAccount: () => reject("getAccount"),
+		getBalance: () => reject("getBalance"),
+		getSigner: () => reject("getSigner"),
+		getTransactionReceipt: () => reject("getTransactionReceipt"),
+		icon,
+		id,
+		name,
+		sendTx: () => reject("sendTx"),
+		sendTxToChain: () => reject("sendTxToChain"),
+		signMessage: () => reject("signMessage"),
+		switchChain: () => reject("switchChain")
+	};
+	switch (entry.chainPlatform) {
+		case "bitcoin": return {
+			...base,
+			chainPlatform: "bitcoin"
+		};
+		case "evm": return {
+			...base,
+			chainPlatform: "evm"
+		};
+		case "sui": return {
+			...base,
+			chainPlatform: "sui"
+		};
+		case "svm": return {
+			...base,
+			chainPlatform: "svm"
+		};
+		case "polkadot": return {
+			...base,
+			chainPlatform: "polkadot"
+		};
+		default:
+			entry.chainPlatform;
+			throw new Error(`[butr] unknown chainPlatform: ${entry.chainPlatform}`);
+	}
+};
+
+//#endregion
+//#region src/store/wallet-store-helpers.ts
+/** Run an async operation fire-and-forget, calling onError if it throws. */
+const run = async (fn, onError) => {
+	try {
+		await fn();
+	} catch (error) {
+		onError(error);
+	}
+};
+
+//#endregion
+//#region src/store/wallet-store.ts
+/**
+* Build a synchronously-populated `State` from `config.initialState`.
+* Each pool entry becomes a `ConnectedWallet` whose `connector` is a
+* shadow adapter; every connector id enters `reconnectingIds` so
+* consumers can branch on "is this connection verified" without
+* waiting for the async silent reconnect. `isHydrated` flips true
+* synchronously — the consumer's first render sees the persisted
+* state in the live store, not undefined.
+*/
+const seedStateFromSnapshot = (snapshot) => {
+	const pool = /* @__PURE__ */ new Map();
+	const reconnectingIds = /* @__PURE__ */ new Set();
+	for (const [connectorId, entry] of Object.entries(snapshot.pool)) {
+		if (!entry) continue;
+		const connector = createShadowAdapter(entry);
+		pool.set(connectorId, {
+			account: entry.account,
+			accounts: [...entry.accounts],
+			connector
+		});
+		reconnectingIds.add(connectorId);
+	}
+	const selection = /* @__PURE__ */ new Map();
+	for (const [platform, connectorId] of Object.entries(snapshot.selection)) if (connectorId && pool.has(connectorId)) selection.set(platform, connectorId);
+	const activeConnectorId = snapshot.activeConnectorId && pool.has(snapshot.activeConnectorId) ? snapshot.activeConnectorId : pool.keys().next().value ?? null;
+	return {
+		...initialState,
+		activeConnectorId,
+		isHydrated: true,
+		pool,
+		reconnectingIds,
+		selection
+	};
+};
+const CONNECT_TIMEOUT_MS = 9e4;
+const DEFAULT_SLOW_CONNECT_THRESHOLD_MS = 5e3;
+const normaliseAddress = (addr) => addr.toLowerCase();
+const createWalletStore = (config) => {
+	const storageKeyPrefix = config.storageKeyPrefix || "butr";
+	const storage = config.storage || new WalletStorage({ keyPrefix: storageKeyPrefix });
+	const reportStorageError = (context) => (error) => {
+		if (config.onStorageError) {
+			try {
+				config.onStorageError(error, context);
+			} catch (cbError) {
+				logWarn("[butr] onStorageError threw:", cbError);
+			}
+			return;
+		}
+		logWarn(`[butr] ${context}:`, error);
+	};
+	const hydration = createHydrationCoordinator(storage, config.createConnector);
+	return createStore()((set, get) => {
+		const dispatch = (event) => {
+			set((prev) => reducer(prev, event), false);
+		};
+		const persistPool = () => run(() => storage.setPool(get().pool), reportStorageError("failed to persist pool"));
+		const persistSelection = () => run(() => storage.setSelection(get().selection), reportStorageError("failed to persist selection"));
+		const persistActive = () => run(() => storage.setActiveConnectorId(get().activeConnectorId), reportStorageError("failed to persist active connector"));
+		const refreshPoolEntry = (connectorId, accounts, active) => {
+			dispatch({
+				accounts,
+				active,
+				connectorId,
+				type: "ACCOUNTS_REFRESHED"
+			});
+			persistPool();
+		};
+		const lifecycle = createConnectorLifecycle({
+			onAccountChanged: (connectorId, accounts, active) => {
+				refreshPoolEntry(connectorId, [...accounts], active);
+			},
+			onDisconnected: (connectorId, chainPlatform) => {
+				dispatch({
+					connectorId,
+					type: "DISCONNECTED"
+				});
+				config.onDisconnect?.(chainPlatform);
+			}
+		});
+		return {
+			...config.initialState ? seedStateFromSnapshot(config.initialState) : initialState,
+			_config: config,
+			_storage: storage,
+			connectWallet: async (connectorId, onSuccess, onError) => {
+				get().setUserDisconnected(false);
+				const connector = config.createConnector(connectorId);
+				if (!connector) throw new Error(`Failed to create connector for ${connectorId}`);
+				dispatch({
+					connectorId,
+					type: "CONNECT_STARTED"
+				});
+				const slowThreshold = config.slowConnectThresholdMs ?? DEFAULT_SLOW_CONNECT_THRESHOLD_MS;
+				const slowTimer = config.onSlowConnect ? setTimeout(() => {
+					try {
+						config.onSlowConnect?.(connectorId);
+					} catch (cbError) {
+						logWarn("[butr] onSlowConnect threw:", cbError);
+					}
+				}, slowThreshold) : null;
+				let connectTimeoutId = null;
+				try {
+					const connectPromise = connector.connect();
+					connectPromise.catch(() => {});
+					await Promise.race([connectPromise, new Promise((_, reject) => {
+						connectTimeoutId = setTimeout(() => {
+							reject(/* @__PURE__ */ new Error("Connection timeout"));
+						}, CONNECT_TIMEOUT_MS);
+					})]);
+					const account = await connector.getAccount();
+					if (!account) throw new Error("Failed to get account");
+					const fetchedAccounts = connector.getAccounts ? await connector.getAccounts().catch(() => null) : null;
+					const entry = {
+						account,
+						accounts: fetchedAccounts && fetchedAccounts.length > 0 ? fetchedAccounts : [account],
+						connector
+					};
+					dispatch({
+						connectorId,
+						entry,
+						type: "CONNECT_SUCCEEDED"
+					});
+					lifecycle.attach(connectorId, connector);
+					await Promise.all([
+						persistPool(),
+						persistSelection(),
+						persistActive()
+					]);
+					config.onConnect?.(entry);
+					onSuccess?.(entry);
+				} catch (error) {
+					const normalised = mapConnectionError(error);
+					dispatch({
+						error: normalised,
+						type: "CONNECT_FAILED"
+					});
+					try {
+						await connector.disconnect?.();
+					} catch (disconnectError) {
+						logWarn("[butr] disconnect during error recovery failed:", disconnectError);
+					}
+					try {
+						config.onConnectError?.(normalised, connectorId);
+					} catch (cbError) {
+						logWarn("[butr] onConnectError threw:", cbError);
+					}
+					onError?.(error);
+					throw error;
+				} finally {
+					if (connectTimeoutId) clearTimeout(connectTimeoutId);
+					if (slowTimer) clearTimeout(slowTimer);
+				}
+			},
+			disconnectWallet: (connectorId) => {
+				get().setUserDisconnected(true);
+				const state = get();
+				if (!state.isHydrated) return;
+				const wallet = state.pool.get(connectorId);
+				if (!wallet) return;
+				lifecycle.detach(connectorId);
+				run(() => wallet.connector.disconnect?.() ?? Promise.resolve(), logError);
+				const platform = wallet.connector.chainPlatform;
+				dispatch({
+					connectorId,
+					type: "DISCONNECTED"
+				});
+				if (get().pool.size === 0) run(() => storage.clearAll(), reportStorageError("failed to clear storage"));
+				else {
+					run(() => storage.removePoolEntry(connectorId), reportStorageError("failed to remove pool entry"));
+					persistSelection();
+					persistActive();
+				}
+				config.onDisconnect?.(platform);
+			},
+			getConnectorInstance: (id) => config.createConnector(id),
+			hydrateWallets: async () => {
+				const result = await hydration.hydrate();
+				dispatch({
+					activeConnectorId: result.activeConnectorId,
+					isUserDisconnected: result.isUserDisconnected,
+					pool: result.pool,
+					selection: result.selection,
+					type: "HYDRATED"
+				});
+				for (const [connectorId, wallet] of result.pool) lifecycle.attach(connectorId, wallet.connector);
+				await Promise.all([persistSelection(), persistActive()]);
+				for (const id of hydration.pendingIds()) run(() => get().tryRestoreFromPending(id), (e) => logWarn(`[butr] late restore rejected for ${id}:`, e));
+				if (config.onHydrated) try {
+					config.onHydrated({
+						dropped: result.dropped,
+						pendingIds: [...result.pendingIds],
+						restoredIds: [...result.pool.keys()]
+					});
+				} catch (cbError) {
+					logWarn("[butr] onHydrated threw:", cbError);
+				}
+				else if (result.dropped.length > 0) for (const { connectorId, reason } of result.dropped) logWarn(`[butr] failed to restore connector ${connectorId}:`, reason);
+			},
+			refreshWallet: (connectorId) => {
+				dispatch({
+					connectorId,
+					type: "WALLET_REFRESHED"
+				});
+			},
+			requestAccounts: async (connectorId) => {
+				const entry = get().pool.get(connectorId);
+				if (!entry) return;
+				await entry.connector.requestAccounts?.();
+				const fresh = entry.connector.getAccounts ? await entry.connector.getAccounts().catch(() => null) : null;
+				if (!fresh || fresh.length === 0) return;
+				refreshPoolEntry(connectorId, fresh);
+			},
+			reset: () => {
+				get().setUserDisconnected(true);
+				const state = get();
+				if (!state.isHydrated) return;
+				lifecycle.detachAll();
+				for (const wallet of state.pool.values()) run(() => wallet.connector.disconnect?.() ?? Promise.resolve(), logError);
+				run(() => storage.clearAll(), reportStorageError("failed to clear storage"));
+				if (config.onReset) {
+					const onReset = config.onReset;
+					run(() => Promise.resolve(onReset()), logError);
+				}
+				dispatch({ type: "RESET" });
+			},
+			resetConnectionStatus: () => {
+				dispatch({ type: "STATUS_RESET" });
+			},
+			setActiveConnector: (connectorId) => {
+				dispatch({
+					connectorId,
+					type: "ACTIVE_CHANGED"
+				});
+				persistActive();
+			},
+			setConnectionError: (error) => {
+				dispatch({
+					error,
+					type: "ERROR_SET"
+				});
+			},
+			setSelection: (chainPlatform, connectorId) => {
+				dispatch({
+					chainPlatform,
+					connectorId,
+					type: "SELECTION_CHANGED"
+				});
+				persistSelection();
+			},
+			setUserDisconnected: (value) => {
+				dispatch({
+					type: "USER_DISCONNECTED_SET",
+					value
+				});
+				run(() => storage.markUserDisconnected(value), reportStorageError("failed to persist disconnect intent"));
+			},
+			tryRestoreFromPending: async (connectorId) => {
+				const outcome = await hydration.drainPending(connectorId);
+				if (!outcome) return;
+				if (outcome.kind === "fail") {
+					logWarn(`[butr] late restore failed for ${connectorId}:`, outcome.error);
+					return;
+				}
+				dispatch({
+					connectorId,
+					entry: outcome.entry,
+					type: "CONNECT_SUCCEEDED"
+				});
+				lifecycle.attach(connectorId, outcome.entry.connector);
+				await Promise.all([
+					persistPool(),
+					persistSelection(),
+					persistActive()
+				]);
+				config.onConnect?.(outcome.entry);
+			},
+			updateWalletAccount: (connectorId, account) => {
+				const entry = get().pool.get(connectorId);
+				if (!entry) return;
+				const newChain = account.chain;
+				const remapped = entry.accounts.map((a) => a.chain.id === newChain.id ? a : {
+					chain: newChain,
+					id: `${newChain.id}:${normaliseAddress(a.walletAddress)}`,
+					walletAddress: a.walletAddress
+				});
+				const accounts = remapped.some((a) => normaliseAddress(a.walletAddress) === normaliseAddress(account.walletAddress)) ? remapped : [...remapped, account];
+				refreshPoolEntry(connectorId, accounts, account);
+			}
+		};
+	});
+};
+
+//#endregion
+//#region src/storage/cookie-storage-driver.ts
+const DEFAULT_MAX_AGE_SECONDS = 3600 * 24 * 30;
+const encode = (value) => encodeURIComponent(value);
+const decode = (value) => decodeURIComponent(value);
+const readCookies = () => {
+	const out = /* @__PURE__ */ new Map();
+	if (typeof document === "undefined") return out;
+	const cookieString = document.cookie;
+	if (!cookieString) return out;
+	for (const segment of cookieString.split(";")) {
+		const trimmed = segment.trim();
+		if (!trimmed) continue;
+		const eq = trimmed.indexOf("=");
+		if (eq === -1) continue;
+		const name = trimmed.slice(0, eq);
+		const raw = trimmed.slice(eq + 1);
+		try {
+			out.set(name, decode(raw));
+		} catch {}
+	}
+	return out;
+};
+const buildCookieString = (name, value, options, expired = false) => {
+	const parts = [`${name}=${encode(value)}`, `Path=${options.path ?? "/"}`];
+	if (options.domain) parts.push(`Domain=${options.domain}`);
+	if (expired) parts.push("Max-Age=0");
+	else {
+		const maxAge = options.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS;
+		parts.push(`Max-Age=${maxAge}`);
+	}
+	parts.push(`SameSite=${options.sameSite ?? "lax"}`);
+	if (options.secure ?? true) parts.push("Secure");
+	return parts.join("; ");
+};
+const toCookieMap$1 = (input) => {
+	if (!input) return null;
+	if (typeof input[Symbol.iterator] === "function") return new Map(input);
+	return new Map(Object.entries(input));
+};
+/**
+* Cookie-backed storage driver. Reads/writes `document.cookie` —
+* server-readable, survives reloads, scoped per `domain`/`path`.
+*
+* **When to use this:** SSR apps that need to know who's connected
+* during the server render (so they can stream the connected-wallet
+* UI without a client-side hydration flicker). Pass `initialCookies`
+* from a server-side cookie source (e.g. `cookies()` in Next.js'
+* `next/headers`, or a parsed `req.headers.cookie`) and the same
+* driver will serve those values during the server render and switch
+* to `document.cookie` once it mounts in the browser.
+*
+* **Trade-offs vs `localStorage`:** cookies travel with every
+* request, so they cost bytes on the wire. Keep the storage key
+* prefix short, and prefer this driver for the `persistent` slot
+* only — the `session` slot can stay in `sessionStorage` (which
+* cookies can't natively model anyway).
+*
+* **Server-side writes are no-ops.** Emitting `Set-Cookie` requires
+* access to the framework's response object, which a storage driver
+* shouldn't reach into. The store doesn't mutate persisted state
+* during the SSR pass anyway — writes only fire after client mount,
+* once `document.cookie` is reachable.
+*/
+const createCookieStorageDriver = (options = {}) => {
+	const seeded = toCookieMap$1(options.initialCookies);
+	if (typeof document === "undefined") {
+		if (!seeded) return {
+			getItem() {
+				return null;
+			},
+			removeItem() {},
+			setItem() {}
+		};
+		return {
+			getItem(key) {
+				return seeded.get(key) ?? null;
+			},
+			removeItem() {},
+			setItem() {}
+		};
+	}
+	return {
+		getItem(key) {
+			return readCookies().get(key) ?? null;
+		},
+		removeItem(key) {
+			document.cookie = buildCookieString(key, "", options, true);
+		},
+		setItem(key, value) {
+			document.cookie = buildCookieString(key, value, options);
+		}
+	};
+};
+
+//#endregion
+//#region src/storage/snapshot.ts
+const VALID_CHAIN_PLATFORMS = new Set(CHAIN_PLATFORMS);
+const EMPTY_SNAPSHOT = Object.freeze({
+	activeConnectorId: null,
+	pool: Object.freeze({}),
+	selection: Object.freeze({})
+});
+const toCookieMap = (input) => {
+	if (typeof input[Symbol.iterator] !== "function") return new Map(Object.entries(input));
+	const out = /* @__PURE__ */ new Map();
+	for (const entry of input) {
+		if (Array.isArray(entry)) {
+			const [name, value] = entry;
+			if (typeof name === "string" && typeof value === "string") out.set(name, value);
+			continue;
+		}
+		if (entry && typeof entry === "object" && "name" in entry && "value" in entry && typeof entry.name === "string" && typeof entry.value === "string") out.set(entry.name, entry.value);
+	}
+	return out;
+};
+const isValidAccount = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const account = value;
+	if (typeof account.walletAddress !== "string" || typeof account.id !== "string") return false;
+	if (!account.chain || typeof account.chain !== "object") return false;
+	return true;
+};
+const isValidPoolEntry = (key, value) => {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	if (typeof entry.connectorId !== "string" || entry.connectorId !== key) return false;
+	if (typeof entry.chainPlatform !== "string") return false;
+	if (!VALID_CHAIN_PLATFORMS.has(entry.chainPlatform)) return false;
+	if (typeof entry.name !== "string" || entry.name.length === 0) return false;
+	if (entry.icon !== void 0 && typeof entry.icon !== "string") return false;
+	if (!isValidAccount(entry.account)) return false;
+	if (!Array.isArray(entry.accounts) || !entry.accounts.every(isValidAccount)) return false;
+	return true;
+};
+const parsePool = (raw) => {
+	if (!raw) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return {};
+		const result = {};
+		for (const [key, value] of Object.entries(parsed)) if (isValidPoolEntry(key, value)) result[key] = value;
+		else logWarn(`[butr] readWalletSnapshot: dropping invalid pool entry for ${key}`);
+		return result;
+	} catch (error) {
+		logWarn("[butr] readWalletSnapshot: failed to parse pool cookie:", error);
+		return {};
+	}
+};
+const parseSelection = (raw) => {
+	if (!raw) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return {};
+		const result = {};
+		for (const [key, value] of Object.entries(parsed)) if (VALID_CHAIN_PLATFORMS.has(key) && typeof value === "string" && value.length > 0) result[key] = value;
+		return result;
+	} catch (error) {
+		logWarn("[butr] readWalletSnapshot: failed to parse selection cookie:", error);
+		return {};
+	}
+};
+/**
+* Parse a cookie source into a server-safe `WalletSnapshot`.
+*
+* Pure, sync, no `document`, no React — runnable in any environment
+* (Server Component, route handler, edge middleware, even client
+* code). Pair with `createCookieStorageDriver({ initialCookies })`
+* and `<WalletManagerProvider initialSnapshot={…} />` to render a
+* connected shell server-side without a hydration flash.
+*
+* **Stale-snapshot semantics.** The snapshot reflects whatever the
+* browser most recently persisted. If the user has since uninstalled
+* the wallet, switched accounts, or disconnected in another tab, the
+* client-side hydration will reconcile reality and the live store
+* will diverge from the snapshot. Treat the snapshot as an
+* *optimistic* shell — accurate enough to avoid a paint flicker,
+* authoritative only after `useIsHydrated()` is true.
+*
+* **Inputs.** Accepts the three shapes Next.js / Express / Hono /
+* generic-Node cookie code naturally produces:
+*  - A plain object: `{ "butr-pool": "{...}", … }`
+*  - An array of `{ name, value }` (Next.js' `cookies().getAll()`)
+*  - An iterable of `[name, value]` tuples
+*
+* Malformed entries are dropped with a `logWarn` (same policy as
+* `WalletStorage.getPool`) — a cross-tab corruption shouldn't crash
+* the server render.
+*/
+const readWalletSnapshot = (source, options = {}) => {
+	const keyPrefix = options.keyPrefix || "butr";
+	const cookies = toCookieMap(source);
+	const pool = parsePool(cookies.get(`${keyPrefix}-pool`));
+	const selection = parseSelection(cookies.get(`${keyPrefix}-selection`));
+	const rawActive = cookies.get(`${keyPrefix}-active`);
+	let activeConnectorId = null;
+	if (rawActive && rawActive.length > 0 && pool[rawActive]) activeConnectorId = rawActive;
+	else {
+		const firstKey = Object.keys(pool)[0];
+		if (firstKey) activeConnectorId = firstKey;
+	}
+	return {
+		activeConnectorId,
+		pool,
+		selection
+	};
+};
+
+//#endregion
+//#region src/wallet-equal.ts
+/**
+* Two wallet snapshots are equivalent for selector purposes iff they
+* share connectorId, active account address, and active account chain
+* id. Used by `useStoreWithEqualityFn` consumers (active-wallet,
+* selected-wallet, useWalletEntry) to suppress spurious re-renders
+* when the underlying Map churns but the resolved entry hasn't changed.
+*
+* Hoisted to its own module so the equivalence rule lives in one place
+* — if we ever extend the snapshot (e.g. to consider `accounts.length`),
+* every selector hook picks up the new rule for free.
+*/
+const walletEqual = (a, b) => {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.connector.id === b.connector.id && a.account.walletAddress === b.account.walletAddress && a.account.chain.id === b.account.chain.id;
+};
+
+//#endregion
+//#region src/sanitize-icon.ts
+/**
+* Normalize a wallet-announced icon string.
+*
+* Wallets announce their icon through external metadata — EIP-6963
+* `providerInfo.icon`, Wallet Standard `wallet.icon`. That value is
+* not under butr's control, and some wallets ship data-URI icons with
+* surrounding whitespace (a newline left over from a pretty-printed
+* manifest). Strict consumers reject it: Next.js's `<Image>` throws
+* because `src` must not start with a control character.
+*
+* Trims surrounding whitespace and treats an all-whitespace (or empty)
+* icon as absent, so consumers get either a usable string or
+* `undefined` — never a blank or malformed one. `undefined` passes
+* through untouched.
+*/
+const sanitizeIcon = (icon) => {
+	if (icon === void 0) return;
+	const trimmed = icon.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+};
+
+//#endregion
+//#region src/encoding/bytes.ts
+/**
+* Shared byte-encoding helpers for the connector packages.
+*
+* These functions sit directly on the signing/address path of every
+* chain. They used to be hand-reimplemented in ~10 connector files; a
+* single tested module removes the drift surface (a `padStart` omission
+* or base64 variant mismatch corrupts signatures/addresses for one chain
+* only, and the divergence is invisible because the copies look "the
+* same").
+*
+* Hex prefixing diverges across chains, so the module exposes **explicit
+* variants** rather than one function:
+* - {@link bytesToHex} returns bare hex (Bitcoin, Ledger).
+* - {@link bytesToHexPrefixed} returns `0x`-prefixed hex (EVM, Polkadot).
+* - {@link hexToBytes} tolerantly strips an optional `0x` (all callers).
+*/
+/** Bare lowercase hex — no `0x` prefix (Bitcoin, Ledger). */
+const bytesToHex = (bytes) => {
+	let hex = "";
+	for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+};
+/** `0x`-prefixed lowercase hex (EVM, Polkadot). */
+const bytesToHexPrefixed = (bytes) => `0x${bytesToHex(bytes)}`;
+/**
+* Decode hex (with or without a leading `0x`) into raw bytes. Throws on
+* odd-length input or non-hex characters rather than silently producing
+* `NaN`-filled bytes.
+*/
+const hexToBytes = (hex) => {
+	const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (clean.length % 2 !== 0) throw new TypeError("Invalid hex: odd length");
+	const out = new Uint8Array(clean.length / 2);
+	for (let i = 0; i < out.length; i += 1) {
+		const byte = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+		if (Number.isNaN(byte)) throw new TypeError(`Invalid hex character at offset ${i * 2}`);
+		out[i] = byte;
+	}
+	return out;
+};
+/**
+* Cross-platform base64 → `Uint8Array`. `atob` is available everywhere
+* butr runs (browsers, RN since Hermes, Node 16+, Bun, Deno).
+*/
+const base64ToBytes = (b64) => {
+	const binary = atob(b64);
+	const out = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i += 1) out[i] = binary.codePointAt(i) ?? 0;
+	return out;
+};
+/** Cross-platform `Uint8Array` → base64. */
+const bytesToBase64 = (bytes) => {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCodePoint(byte);
+	return btoa(binary);
+};
+
+//#endregion
+export { CHAIN_PLATFORMS, EMPTY_SNAPSHOT, WalletStorage, base64ToBytes, buildChainsByPlatform, bytesToBase64, bytesToHex, bytesToHexPrefixed, createBrowserStorageDriver, createCookieStorageDriver, createMemoryStorageDriver, createWalletSource, createWalletStore, hexToBytes, logError, logWarn, mapConnectionError, readWalletSnapshot, sanitizeIcon, walletEqual };
 //# sourceMappingURL=index.js.map