@yeying-community/web3-bs 1.0.2 → 1.0.3

package/README.md

@@ -9,6 +9,189 @@
 npm install @yeying-community/web3-bs
 ```
 
+## Dapp 集成（浏览器）
+
+SDK 仅支持浏览器环境。推荐两种接入方式：
+
+### 方式一：模块化（打包器 / Vite / Webpack）
+
+```ts
+import { getProvider, loginWithChallenge, authFetch } from '@yeying-community/web3-bs';
+
+const provider = await getProvider({ timeoutMs: 3000 });
+const login = await loginWithChallenge({
+  provider,
+  baseUrl: 'http://localhost:3203/api/v1/public/auth',
+  storeToken: false,
+});
+
+const res = await authFetch('http://localhost:3203/api/v1/public/profile', { method: 'GET' }, {
+  baseUrl: 'http://localhost:3203/api/v1/public/auth',
+  storeToken: false,
+});
+console.log(await res.json());
+```
+
+### 方式二：UMD（纯 HTML）
+
+```html
+<script src="https://your-host/dist/web3-bs.umd.js"></script>
+<script>
+  const { getProvider, loginWithChallenge } = window.YeYingWeb3;
+  async function login() {
+    const provider = await getProvider({ timeoutMs: 3000 });
+    const result = await loginWithChallenge({
+      provider,
+      baseUrl: 'http://localhost:3203/api/v1/public/auth',
+      storeToken: false,
+    });
+    console.log(result);
+  }
+  login();
+</script>
+```
+
+提示：UMD 模式下全局对象为 `window.YeYingWeb3`，需要保证 `dist/web3-bs.umd.js` 可访问。
+
+## SIWE 登录（不使用 UCAN）
+
+如果只需要传统 SIWE + JWT 登录（单后端），可以不启用 UCAN：
+
+```ts
+import { getProvider, loginWithChallenge, authFetch, refreshAccessToken, logout } from '@yeying-community/web3-bs';
+
+const provider = await getProvider();
+const login = await loginWithChallenge({
+  provider,
+  baseUrl: 'http://localhost:3203/api/v1/public/auth',
+  storeToken: false,
+});
+
+const profile = await authFetch('http://localhost:3203/api/v1/public/profile', { method: 'GET' }, {
+  baseUrl: 'http://localhost:3203/api/v1/public/auth',
+  storeToken: false,
+});
+console.log(await profile.json());
+
+await refreshAccessToken({ baseUrl: 'http://localhost:3203/api/v1/public/auth', storeToken: false });
+await logout({ baseUrl: 'http://localhost:3203/api/v1/public/auth', storeToken: false });
+```
+
+## SIWE 与 UCAN 完整登录流程
+
+### SIWE vs UCAN 对比（token 来源 / 有效期 / 续期方式）
+
+| 维度 | SIWE 登录（JWT） | UCAN 授权 |
+| --- | --- | --- |
+| Token 来源 | 后端签发 access token + refresh cookie | 前端生成 UCAN（Root/Invocation），后端只校验 |
+| 有效期 | access/refresh 由后端配置 | Invocation 默认 5 分钟，Root 默认 24 小时（可配置） |
+| 续期方式 | `POST /auth/refresh`（refresh cookie） | 重新生成 Invocation；Root 过期则重新生成 Root + Invocation |
+
+### SIWE-only（单后端）
+1. 前端检测钱包 Provider（`getProvider` / `requestAccounts`）。
+2. 请求后端 challenge：`POST /api/v1/public/auth/challenge`。
+3. 钱包签名 challenge（`personal_sign`）。
+4. 提交签名到后端：`POST /api/v1/public/auth/verify`，获取 access token + refresh cookie。
+5. 访问业务接口：`Authorization: Bearer <access-token>`（`authFetch` 会自动附带）。
+6. access 过期时刷新：`POST /api/v1/public/auth/refresh`（依赖 httpOnly refresh cookie）。
+7. 退出登录：`POST /api/v1/public/auth/logout`。
+
+Mermaid：
+
+```mermaid
+sequenceDiagram
+  actor 用户
+  participant FE as Dapp 前端
+  participant WP as 钱包 Provider
+  participant BE as 认证后端
+
+  用户 ->> FE: 打开 Dapp / 点击登录
+  FE ->> WP: 获取 Provider / 请求账户
+  FE ->> BE: POST /auth/challenge { address }
+  BE -->> FE: 返回 challenge, nonce
+  FE ->> WP: 签名 challenge
+  WP -->> FE: 返回 signature
+  FE ->> BE: POST /auth/verify { address, signature }
+  BE -->> FE: 返回 access token + refresh cookie
+  FE ->> BE: GET /public/profile (Authorization: Bearer access)
+  BE -->> FE: 返回业务数据
+  FE ->> BE: POST /auth/refresh (refresh cookie)
+  BE -->> FE: 返回新 access token
+  FE ->> BE: POST /auth/logout
+  BE -->> FE: 登出成功
+```
+
+### UCAN（多后端 / Delegation）
+1. 前端检测钱包 Provider（`getProvider` / `requestAccounts`）。
+2. 由钱包生成 UCAN Session Key：`createUcanSession`。
+3. 用 SIWE 作为桥梁生成 Root UCAN（包含能力 `[{ resource, action }]`）：`createRootUcan` 或 `getOrCreateUcanRoot`。
+4. 针对每个后端生成 Invocation UCAN：`createInvocationUcan({ issuer: session, audience, capabilities, proofs: [root] })`。
+5. 调用后端业务接口：`Authorization: Bearer <UCAN>`（可用 `authUcanFetch`）。
+6. 如需可转授权，先生成 Delegation UCAN：`createDelegationUcan`，由被委任方再生成 Invocation UCAN。
+7. Root/Invocation 过期时重新生成（或由 `initWebDavStorage` 自动处理）。
+提示：Root 过期后前端应重新授权并重试（重新生成 Root + Invocation）。
+
+推荐重试逻辑示例：
+```ts
+import { getOrCreateUcanRoot, createInvocationUcan } from '@yeying-community/web3-bs';
+
+async function callWithUcanRetry(target, caps, provider, session) {
+  const root = await getOrCreateUcanRoot({ provider, session, capabilities: caps });
+  let token = await createInvocationUcan({
+    issuer: session,
+    audience: target.aud,
+    capabilities: caps,
+    proofs: [root],
+  });
+
+  let res = await fetch(target.url, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (res.status !== 401) return res;
+
+  // Root 过期：重新生成 Root 并重试一次
+  const newRoot = await getOrCreateUcanRoot({ provider, session, capabilities: caps, expiresInMs: 24 * 60 * 60 * 1000 });
+  token = await createInvocationUcan({
+    issuer: session,
+    audience: target.aud,
+    capabilities: caps,
+    proofs: [newRoot],
+  });
+  return await fetch(target.url, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+}
+```
+
+Mermaid：
+
+```mermaid
+sequenceDiagram
+  actor 用户
+  participant FE as Dapp 前端
+  participant WP as 钱包 Provider
+  participant BA as 后端 A
+  participant BB as 后端 B
+
+  用户 ->> FE: 打开 Dapp / 初始化 UCAN
+  FE ->> WP: createUcanSession
+  WP -->> FE: 返回 UCAN session key (did, signer)
+  FE ->> WP: createRootUcan (SIWE 桥接)
+  WP -->> FE: 返回 Root UCAN (proof)
+
+  FE ->> WP: createInvocationUcan(audience=后端 A)
+  WP -->> FE: 返回 Invocation UCAN (A)
+  FE ->> BA: GET /public/profile (Authorization: Bearer UCAN-A)
+  BA -->> FE: 返回响应
+
+  FE ->> WP: createInvocationUcan(audience=后端 B)
+  WP -->> FE: 返回 Invocation UCAN (B)
+  FE ->> BB: GET /public/profile (Authorization: Bearer UCAN-B)
+  BB -->> FE: 返回响应
+
+  Note over FE,WP: 可选委任链\ncreateDelegationUcan -> 转交 -> createInvocationUcan
+```
+
 ## 钱包交互 API
 
 ### Provider 发现
@@ -179,7 +362,7 @@ const ucan = await createInvocationUcan({
   proofs: [root],
 });
 
-const res = await authUcanFetch('http://localhost:3203/api/v1/private/profile', { method: 'GET' }, { ucan });
+const res = await authUcanFetch('http://localhost:3203/api/v1/public/profile', { method: 'GET' }, { ucan });
 console.log(await res.json());
 ```
 
@@ -194,9 +377,13 @@ console.log(await res.json());
 
 提供基于 WebDAV 服务的文件操作封装（上传/下载/删除/目录等），适配 `webdav` 项目 API。
 
+新增便捷能力：
+- `initWebDavStorage`：自动生成/复用 UCAN Invocation Token，并可在首次使用时创建应用目录
+- `ensureDirectory(path)`：递归创建目录（存在时自动跳过）
+
 示例：
 ```ts
-import { createWebDavClient, loginWithChallenge } from '@yeying-community/web3-bs';
+import { createWebDavClient, initWebDavStorage, loginWithChallenge } from '@yeying-community/web3-bs';
 
 const login = await loginWithChallenge({
   provider,
@@ -213,6 +400,15 @@ const client = createWebDavClient({
 const listingXml = await client.listDirectory('/');
 await client.upload('/docs/hello.txt', 'Hello WebDAV');
 const content = await client.downloadText('/docs/hello.txt');
+
+// UCAN 登录 + 自动创建应用目录（推荐）
+const storage = await initWebDavStorage({
+  baseUrl: 'http://localhost:6065',
+  audience: 'did:web:localhost:6065',
+  appId: 'my-dapp',
+  capabilities: [{ resource: 'profile', action: 'read' }],
+});
+await storage.client.upload(`${storage.appDir}/hello.txt`, 'Hello WebDAV');
 ```
 
 常用方法：
@@ -220,18 +416,46 @@ const content = await client.downloadText('/docs/hello.txt');
 - `upload(path, content, contentType?)`
 - `download(path)` / `downloadText(path)` / `downloadArrayBuffer(path)`
 - `createDirectory(path)`（MKCOL）
+- `ensureDirectory(path)`（递归 MKCOL，已存在会跳过）
 - `remove(path)`（DELETE）
 - `move(path, destination, overwrite?)`
 - `copy(path, destination, overwrite?)`
 - `getQuota()` / `listRecycle()` / `recoverRecycle(hash)` / `deleteRecycle(hash)` / `clearRecycle()`
 
+提示：`capabilities` 需与 WebDAV 后端 UCAN 策略一致；`appId` 默认映射为 `/apps/<appId>`。
+
+## Dapp 快速接入（推荐）
+
+一次完成 SIWE 登录 + UCAN WebDAV 初始化 + 创建应用目录：
+
+```ts
+import { initDappSession } from '@yeying-community/web3-bs';
+
+const session = await initDappSession({
+  appAuth: {
+    baseUrl: 'http://localhost:3203/api/v1/public/auth',
+    storeToken: false,
+  },
+  webdav: {
+    baseUrl: 'http://localhost:6065',
+    audience: 'did:web:localhost:6065',
+    appId: 'my-dapp',
+    capabilities: [{ resource: 'profile', action: 'read' }],
+  },
+});
+
+const webdav = session.webdavClient;
+await webdav?.upload(`${session.webdavAppDir}/hello.txt`, 'Hello WebDAV');
+```
+
 ## 本地验证
 
 1. 构建 SDK：`npm run build`
 2. 启动后端：`node examples/backend/node/server.js`
-3. 启动前端：`python3 -m http.server 8001`，然后在浏览器输入访问地址：`http://localhost:8001/examples/frontend/dapp.html`
-4. 确保安装 YeYing 钱包扩展插件
-5. 点击：`Detect Provider` → `Connect Wallet` → `Login`
+3. 启动前端：`python3 -m http.server 8001`
+4. 访问：`http://localhost:8001/examples/frontend/dapp.html`
+5. 确保安装 YeYing 钱包扩展插件
+6. 点击：`Detect Provider` → `Connect Wallet` → `Login`
 
 提示：如果前端来自其他域名，请设置
 `COOKIE_SAMESITE=none` 且 `COOKIE_SECURE=true` 并使用 HTTPS，

package/dist/auth/ucan.d.ts

@@ -86,6 +86,7 @@ export declare function createUcanSession(options?: CreateUcanSessionOptions): P
 export declare function clearUcanSession(id?: string): Promise<void>;
 export declare function storeUcanRoot(root: UcanRootProof, id?: string): Promise<void>;
 export declare function getStoredUcanRoot(id?: string): Promise<UcanRootProof | null>;
+export declare function getOrCreateUcanRoot(options: CreateRootUcanOptions): Promise<UcanRootProof>;
 export declare function createRootUcan(options: CreateRootUcanOptions): Promise<UcanRootProof>;
 export declare function createDelegationUcan(options: CreateUcanTokenOptions): Promise<string>;
 export declare function createInvocationUcan(options: CreateUcanTokenOptions): Promise<string>;

package/dist/dapp.d.ts

@@ -0,0 +1,48 @@
+import { loginWithChallenge } from './auth/siwe';
+import { UcanCapability, UcanRootProof, UcanSessionKey } from './auth/ucan';
+import { Eip1193Provider, LoginWithChallengeOptions } from './auth/types';
+import { WebDavClient } from './storage/webdav';
+export type InitWebDavStorageOptions = {
+    baseUrl: string;
+    audience: string;
+    prefix?: string;
+    appDir?: string;
+    appId?: string;
+    ensureAppDir?: boolean;
+    capabilities?: UcanCapability[];
+    invocationCapabilities?: UcanCapability[];
+    provider?: Eip1193Provider;
+    sessionId?: string;
+    session?: UcanSessionKey;
+    root?: UcanRootProof;
+    rootExpiresInMs?: number;
+    invocationExpiresInMs?: number;
+    notBeforeMs?: number;
+    fetcher?: typeof fetch;
+    credentials?: RequestCredentials;
+};
+export type InitWebDavStorageResult = {
+    client: WebDavClient;
+    token: string;
+    appDir?: string;
+    session: UcanSessionKey;
+    root: UcanRootProof;
+};
+export type InitDappSessionOptions = {
+    provider?: Eip1193Provider;
+    address?: string;
+    appAuth?: LoginWithChallengeOptions;
+    webdav?: InitWebDavStorageOptions;
+};
+export type InitDappSessionResult = {
+    provider: Eip1193Provider;
+    address?: string;
+    appLogin?: Awaited<ReturnType<typeof loginWithChallenge>>;
+    ucanSession?: UcanSessionKey;
+    ucanRoot?: UcanRootProof;
+    webdavClient?: WebDavClient;
+    webdavToken?: string;
+    webdavAppDir?: string;
+};
+export declare function initWebDavStorage(options: InitWebDavStorageOptions): Promise<InitWebDavStorageResult>;
+export declare function initDappSession(options: InitDappSessionOptions): Promise<InitDappSessionResult>;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './auth';
 export * from './storage';
+export * from './dapp';

package/dist/storage/webdav.d.ts

@@ -42,6 +42,7 @@ export declare class WebDavClient {
     downloadArrayBuffer(path: string): Promise<ArrayBuffer>;
     upload(path: string, content: BodyInit, contentType?: string): Promise<Response>;
     createDirectory(path: string): Promise<Response>;
+    ensureDirectory(path: string): Promise<void>;
     remove(path: string): Promise<Response>;
     move(path: string, destination: string, overwrite?: boolean): Promise<Response>;
     copy(path: string, destination: string, overwrite?: boolean): Promise<Response>;

package/dist/web3-bs.esm.js

@@ -637,6 +637,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 +680,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];
@@ -925,6 +952,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 +1056,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, getProvider, getStoredUcanRoot, getUcanSession, initDappSession, initWebDavStorage, isYeYingProvider, loginWithChallenge, logout, onAccountsChanged, onChainChanged, refreshAccessToken, requestAccounts, requireProvider, setAccessToken, signMessage, storeUcanRoot };
 //# sourceMappingURL=web3-bs.esm.js.map