@yeying-community/web3-bs 1.0.3 → 1.0.5

package/dist/web3-bs.umd.js

@@ -6,11 +6,43 @@
 
     const YEYING_RDNS = 'io.github.yeying';
     const DEFAULT_TIMEOUT = 1000;
+    const DEFAULT_ACCOUNT_STORAGE_KEY = 'yeying:last_account';
     function getWindowEthereum() {
         if (typeof window === 'undefined')
             return null;
         return window.ethereum || null;
     }
+    function readStoredAccount(storageKey) {
+        if (typeof localStorage === 'undefined')
+            return null;
+        try {
+            return localStorage.getItem(storageKey);
+        }
+        catch {
+            return null;
+        }
+    }
+    function writeStoredAccount(storageKey, account) {
+        if (typeof localStorage === 'undefined')
+            return;
+        try {
+            if (account) {
+                localStorage.setItem(storageKey, account);
+            }
+            else {
+                localStorage.removeItem(storageKey);
+            }
+        }
+        catch {
+            // ignore storage errors
+        }
+    }
+    function selectPreferredAccount(accounts, stored, preferStored) {
+        if (preferStored && stored && accounts.includes(stored)) {
+            return stored;
+        }
+        return accounts[0] || null;
+    }
     function isYeYingProvider(provider, info) {
         if (!provider)
             return false;
@@ -116,6 +148,29 @@
         const chainId = (await p.request({ method: 'eth_chainId' }));
         return typeof chainId === 'string' ? chainId : null;
     }
+    async function getPreferredAccount(options = {}) {
+        const provider = options.provider || (await requireProvider());
+        const storageKey = options.storageKey || DEFAULT_ACCOUNT_STORAGE_KEY;
+        const preferStored = options.preferStored !== false;
+        let accounts = await getAccounts(provider);
+        if (accounts.length === 0 && options.autoConnect) {
+            accounts = await requestAccounts({ provider });
+        }
+        const stored = readStoredAccount(storageKey);
+        const account = selectPreferredAccount(accounts, stored, preferStored);
+        writeStoredAccount(storageKey, account);
+        return { account, accounts };
+    }
+    function watchAccounts(provider, handler, options = {}) {
+        const storageKey = options.storageKey || DEFAULT_ACCOUNT_STORAGE_KEY;
+        const preferStored = options.preferStored !== false;
+        return onAccountsChanged(provider, (accounts) => {
+            const stored = readStoredAccount(storageKey);
+            const account = selectPreferredAccount(accounts, stored, preferStored);
+            writeStoredAccount(storageKey, account);
+            handler({ account, accounts });
+        });
+    }
     async function getBalance(provider, address, blockTag = 'latest') {
         const p = provider || (await requireProvider());
         let target = address;
@@ -714,8 +769,8 @@
         const session = options.session || (await createUcanSession({ id: options.sessionId, provider }));
         const address = await resolveAddress(provider, options.address);
         const chainId = options.chainId || (await getChainId(provider)) || '1';
-        const domain = options.domain || (typeof window !== 'undefined' ? window.location.host : 'localhost');
-        const uri = options.uri || (typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
+        const domain = options.domain || (typeof window !== 'undefined' ? window.location.host : '127.0.0.1');
+        const uri = options.uri || (typeof window !== 'undefined' ? window.location.origin : 'http://127.0.0.1');
         const nonce = options.nonce || randomNonce(8);
         const exp = normalizeExpiry(undefined, options.expiresInMs ?? DEFAULT_SESSION_TTL);
         const nbf = options.notBeforeMs;
@@ -1064,6 +1119,7 @@
 
     const tokenCache = new Map();
     const TOKEN_SKEW_MS = 5000;
+    const DEFAULT_APP_ACTION = 'write';
     function normalizeAppDir(path) {
         const trimmed = path.trim();
         if (!trimmed)
@@ -1075,6 +1131,42 @@
     function sanitizeAppId(appId) {
         return appId.trim().replace(/[^a-zA-Z0-9._-]/g, '-');
     }
+    function normalizeAction(action) {
+        const trimmed = (action || '').trim();
+        return trimmed ? trimmed : null;
+    }
+    function buildAppCapability(options) {
+        if (!options.appId)
+            return null;
+        const action = normalizeAction(options.appAction) || DEFAULT_APP_ACTION;
+        return {
+            resource: `app:${sanitizeAppId(options.appId)}`,
+            action,
+        };
+    }
+    function hasAppCapability(caps) {
+        return (caps || []).some(cap => typeof cap?.resource === 'string' && cap.resource.startsWith('app:'));
+    }
+    function dedupeCapabilities(caps) {
+        const seen = new Set();
+        return (caps || []).filter(cap => {
+            if (!cap || !cap.resource || !cap.action)
+                return false;
+            const key = `${cap.resource}|${cap.action}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    function ensureAppCapability(caps, options) {
+        const appCap = buildAppCapability(options);
+        if (!appCap)
+            return caps || [];
+        if (hasAppCapability(caps || []))
+            return caps || [];
+        return dedupeCapabilities([...(caps || []), appCap]);
+    }
     function resolveAppDir(options) {
         if (options.appDir) {
             return normalizeAppDir(options.appDir);
@@ -1090,6 +1182,14 @@
     function buildTokenCacheKey(issuer, audience, caps) {
         return `${issuer.did}|${audience}|${buildCapsKey(caps)}`;
     }
+    function resolveWebdavCaps(options) {
+        const baseCaps = options.capabilities || options.root?.cap || [];
+        return ensureAppCapability(baseCaps, options);
+    }
+    function resolveInvocationCaps(options, fallbackCaps) {
+        const caps = options.invocationCapabilities || fallbackCaps;
+        return ensureAppCapability(caps, options);
+    }
     function isTokenValid(entry, nowMs) {
         if (!entry.exp)
             return false;
@@ -1161,7 +1261,7 @@
         return token;
     }
     async function initWebDavStorage(options) {
-        const caps = options.capabilities || options.root?.cap;
+        const caps = resolveWebdavCaps(options);
         if (!caps || caps.length === 0) {
             throw new Error('Missing UCAN capabilities for WebDAV');
         }
@@ -1191,7 +1291,7 @@
                 expiresInMs: options.rootExpiresInMs,
             });
         }
-        const invocationCaps = options.invocationCapabilities || caps;
+        const invocationCaps = resolveInvocationCaps(options, caps);
         const token = await getCachedInvocationToken({
             issuer: session,
             audience: options.audience,
@@ -1269,6 +1369,7 @@
     exports.getBalance = getBalance;
     exports.getChainId = getChainId;
     exports.getOrCreateUcanRoot = getOrCreateUcanRoot;
+    exports.getPreferredAccount = getPreferredAccount;
     exports.getProvider = getProvider;
     exports.getStoredUcanRoot = getStoredUcanRoot;
     exports.getUcanSession = getUcanSession;
@@ -1285,6 +1386,7 @@
     exports.setAccessToken = setAccessToken;
     exports.signMessage = signMessage;
     exports.storeUcanRoot = storeUcanRoot;
+    exports.watchAccounts = watchAccounts;
 
 }));
 //# sourceMappingURL=web3-bs.umd.js.map