@yeying-community/web3-bs 1.0.2 → 1.0.4

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;
@@ -643,6 +698,25 @@
         const record = await readSessionRecord(id);
         return record?.root || null;
     }
+    function capsEqual(a, b) {
+        return JSON.stringify(a || []) === JSON.stringify(b || []);
+    }
+    function isRootExpired(root, nowMs) {
+        return Boolean(root.exp && nowMs > root.exp);
+    }
+    async function getOrCreateUcanRoot(options) {
+        const provider = options.provider || (await requireProvider());
+        const session = options.session || (await createUcanSession({ id: options.sessionId, provider }));
+        const nowMs = Date.now();
+        const stored = await getStoredUcanRoot(session.id);
+        if (stored &&
+            (!stored.aud || stored.aud === session.did) &&
+            capsEqual(stored.cap, options.capabilities) &&
+            !isRootExpired(stored, nowMs)) {
+            return stored;
+        }
+        return await createRootUcan({ ...options, provider, session });
+    }
     function buildUcanStatement(payload) {
         return `UCAN-AUTH ${JSON.stringify(payload)}`;
     }
@@ -667,7 +741,15 @@
     async function resolveAddress(provider, address) {
         if (address)
             return address;
-        const accounts = await getAccounts(provider);
+        let accounts = await getAccounts(provider);
+        if (!accounts[0]) {
+            const requested = (await provider.request({
+                method: 'eth_requestAccounts',
+            }));
+            if (Array.isArray(requested)) {
+                accounts = requested;
+            }
+        }
         if (!accounts[0])
             throw new Error('No account available');
         return accounts[0];
@@ -687,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;
@@ -931,6 +1013,27 @@
         async createDirectory(path) {
             return await this.request('MKCOL', path);
         }
+        async ensureDirectory(path) {
+            if (!path || path === '/')
+                return;
+            const segments = path.split('/').filter(Boolean);
+            if (segments.length === 0)
+                return;
+            let current = '';
+            for (const segment of segments) {
+                current = `${current}/${segment}`;
+                const res = await this.fetcher(this.buildUrl(current), {
+                    method: 'MKCOL',
+                    headers: this.buildHeaders(),
+                    credentials: this.credentials,
+                });
+                if (res.ok)
+                    continue;
+                if (res.status === 405)
+                    continue;
+                throw new Error(`WebDAV MKCOL ${current} failed: ${res.status} ${res.statusText}`);
+            }
+        }
         async remove(path) {
             return await this.request('DELETE', path);
         }
@@ -1014,6 +1117,198 @@
         return new WebDavClient(options);
     }
 
+    const tokenCache = new Map();
+    const TOKEN_SKEW_MS = 5000;
+    function normalizeAppDir(path) {
+        const trimmed = path.trim();
+        if (!trimmed)
+            return '/';
+        let next = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+        next = next.replace(/\/+$/, '');
+        return next || '/';
+    }
+    function sanitizeAppId(appId) {
+        return appId.trim().replace(/[^a-zA-Z0-9._-]/g, '-');
+    }
+    function resolveAppDir(options) {
+        if (options.appDir) {
+            return normalizeAppDir(options.appDir);
+        }
+        if (options.appId) {
+            return normalizeAppDir(`/apps/${sanitizeAppId(options.appId)}`);
+        }
+        return undefined;
+    }
+    function buildCapsKey(caps) {
+        return JSON.stringify(caps || []);
+    }
+    function buildTokenCacheKey(issuer, audience, caps) {
+        return `${issuer.did}|${audience}|${buildCapsKey(caps)}`;
+    }
+    function isTokenValid(entry, nowMs) {
+        if (!entry.exp)
+            return false;
+        if (entry.nbf && nowMs < entry.nbf)
+            return false;
+        return entry.exp - TOKEN_SKEW_MS > nowMs;
+    }
+    function decodeBase64Url(input) {
+        if (!input)
+            return null;
+        const base64 = input.replace(/-/g, '+').replace(/_/g, '/');
+        const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, '=');
+        try {
+            if (typeof atob === 'function') {
+                return atob(padded);
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            const nodeBuffer = globalThis.Buffer;
+            if (nodeBuffer) {
+                return nodeBuffer.from(padded, 'base64').toString('utf8');
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    function decodeUcanPayload(token) {
+        const parts = token.split('.');
+        if (parts.length < 2)
+            return null;
+        const decoded = decodeBase64Url(parts[1]);
+        if (!decoded)
+            return null;
+        try {
+            return JSON.parse(decoded);
+        }
+        catch {
+            return null;
+        }
+    }
+    async function getCachedInvocationToken(options) {
+        const cacheKey = buildTokenCacheKey(options.issuer, options.audience, options.capabilities);
+        const cached = tokenCache.get(cacheKey);
+        const nowMs = Date.now();
+        if (cached && isTokenValid(cached, nowMs)) {
+            return cached.token;
+        }
+        const token = await createInvocationUcan({
+            issuer: options.issuer,
+            audience: options.audience,
+            capabilities: options.capabilities,
+            proofs: options.proofs,
+            expiresInMs: options.expiresInMs,
+            notBeforeMs: options.notBeforeMs,
+        });
+        const payload = decodeUcanPayload(token);
+        if (payload && typeof payload.exp === 'number') {
+            tokenCache.set(cacheKey, {
+                token,
+                exp: payload.exp,
+                nbf: payload.nbf,
+            });
+        }
+        return token;
+    }
+    async function initWebDavStorage(options) {
+        const caps = options.capabilities || options.root?.cap;
+        if (!caps || caps.length === 0) {
+            throw new Error('Missing UCAN capabilities for WebDAV');
+        }
+        const needsProvider = !options.session || !options.root;
+        const provider = options.provider || (needsProvider ? await requireProvider() : undefined);
+        const session = options.session ||
+            (await createUcanSession({
+                id: options.sessionId,
+                provider,
+            }));
+        const nowMs = Date.now();
+        let root = options.root;
+        if (root && root.aud && root.aud !== session.did) {
+            root = undefined;
+        }
+        if (root && buildCapsKey(root.cap) !== buildCapsKey(caps)) {
+            root = undefined;
+        }
+        if (root && root.exp && nowMs > root.exp) {
+            root = undefined;
+        }
+        if (!root) {
+            root = await getOrCreateUcanRoot({
+                provider: provider || (await requireProvider()),
+                session,
+                capabilities: caps,
+                expiresInMs: options.rootExpiresInMs,
+            });
+        }
+        const invocationCaps = options.invocationCapabilities || caps;
+        const token = await getCachedInvocationToken({
+            issuer: session,
+            audience: options.audience,
+            capabilities: invocationCaps,
+            proofs: [root],
+            expiresInMs: options.invocationExpiresInMs,
+            notBeforeMs: options.notBeforeMs,
+        });
+        const client = createWebDavClient({
+            baseUrl: options.baseUrl,
+            prefix: options.prefix,
+            token,
+            fetcher: options.fetcher,
+            credentials: options.credentials,
+        });
+        const appDir = resolveAppDir(options);
+        if (appDir && options.ensureAppDir !== false) {
+            await client.ensureDirectory(appDir);
+        }
+        return {
+            client,
+            token,
+            appDir,
+            session,
+            root,
+        };
+    }
+    async function initDappSession(options) {
+        if (!options.appAuth && !options.webdav) {
+            throw new Error('No init options provided');
+        }
+        const provider = options.provider ||
+            options.appAuth?.provider ||
+            options.webdav?.provider ||
+            (await requireProvider());
+        const result = {
+            provider,
+            address: options.address,
+        };
+        if (options.appAuth) {
+            const appLogin = await loginWithChallenge({
+                ...options.appAuth,
+                provider: options.appAuth.provider || provider,
+                address: options.appAuth.address || options.address,
+            });
+            result.appLogin = appLogin;
+            result.address = appLogin.address;
+        }
+        if (options.webdav) {
+            const webdav = await initWebDavStorage({
+                ...options.webdav,
+                provider: options.webdav.provider || provider,
+            });
+            result.ucanSession = webdav.session;
+            result.ucanRoot = webdav.root;
+            result.webdavClient = webdav.client;
+            result.webdavToken = webdav.token;
+            result.webdavAppDir = webdav.appDir;
+        }
+        return result;
+    }
+
     exports.WebDavClient = WebDavClient;
     exports.authFetch = authFetch;
     exports.authUcanFetch = authUcanFetch;
@@ -1028,9 +1323,13 @@
     exports.getAccounts = getAccounts;
     exports.getBalance = getBalance;
     exports.getChainId = getChainId;
+    exports.getOrCreateUcanRoot = getOrCreateUcanRoot;
+    exports.getPreferredAccount = getPreferredAccount;
     exports.getProvider = getProvider;
     exports.getStoredUcanRoot = getStoredUcanRoot;
     exports.getUcanSession = getUcanSession;
+    exports.initDappSession = initDappSession;
+    exports.initWebDavStorage = initWebDavStorage;
     exports.isYeYingProvider = isYeYingProvider;
     exports.loginWithChallenge = loginWithChallenge;
     exports.logout = logout;
@@ -1042,6 +1341,7 @@
     exports.setAccessToken = setAccessToken;
     exports.signMessage = signMessage;
     exports.storeUcanRoot = storeUcanRoot;
+    exports.watchAccounts = watchAccounts;
 
 }));
 //# sourceMappingURL=web3-bs.umd.js.map