@yeying-community/web3-bs 1.0.2 → 1.0.4

package/dist/web3-bs.esm.js

@@ -1,10 +1,42 @@
 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;
@@ -110,6 +142,29 @@ async function getChainId(provider) {
     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;
@@ -637,6 +692,25 @@ async function getStoredUcanRoot(id = DEFAULT_SESSION_ID) {
     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)}`;
 }
@@ -661,7 +735,15 @@ function buildSiweMessage(params) {
 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];
@@ -681,8 +763,8 @@ async function createRootUcan(options) {
     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;
@@ -925,6 +1007,27 @@ class WebDavClient {
     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);
     }
@@ -1008,5 +1111,197 @@ function createWebDavClient(options) {
     return new WebDavClient(options);
 }
 
-export { WebDavClient, authFetch, authUcanFetch, clearAccessToken, clearUcanSession, createDelegationUcan, createInvocationUcan, createRootUcan, createUcanSession, createWebDavClient, getAccessToken, getAccounts, getBalance, getChainId, getProvider, getStoredUcanRoot, getUcanSession, isYeYingProvider, loginWithChallenge, logout, onAccountsChanged, onChainChanged, refreshAccessToken, requestAccounts, requireProvider, setAccessToken, signMessage, storeUcanRoot };
+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;
+}
+
+export { WebDavClient, authFetch, authUcanFetch, clearAccessToken, clearUcanSession, createDelegationUcan, createInvocationUcan, createRootUcan, createUcanSession, createWebDavClient, getAccessToken, getAccounts, getBalance, getChainId, getOrCreateUcanRoot, getPreferredAccount, getProvider, getStoredUcanRoot, getUcanSession, initDappSession, initWebDavStorage, isYeYingProvider, loginWithChallenge, logout, onAccountsChanged, onChainChanged, refreshAccessToken, requestAccounts, requireProvider, setAccessToken, signMessage, storeUcanRoot, watchAccounts };
 //# sourceMappingURL=web3-bs.esm.js.map