@calimero-network/mero-react 9.1.3 → 9.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -2
- package/dist/index.cjs +1423 -52
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +814 -19
- package/dist/index.d.ts +814 -19
- package/dist/index.js +1405 -54
- package/dist/index.js.map +1 -1
- package/package.json +3 -2
package/dist/index.cjs
CHANGED
|
@@ -280,6 +280,293 @@ function clearAllStorage() {
|
|
|
280
280
|
localStorage.removeItem(key);
|
|
281
281
|
});
|
|
282
282
|
}
|
|
283
|
+
var KEY = "calimero.delegated.connection";
|
|
284
|
+
var CREDENTIAL_KEY = "calimero.delegated.credential";
|
|
285
|
+
function readDelegatedSession() {
|
|
286
|
+
if (typeof sessionStorage === "undefined") return null;
|
|
287
|
+
try {
|
|
288
|
+
const raw = sessionStorage.getItem(KEY);
|
|
289
|
+
return raw ? JSON.parse(raw) : null;
|
|
290
|
+
} catch {
|
|
291
|
+
return null;
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
function saveDelegatedSession(s) {
|
|
295
|
+
try {
|
|
296
|
+
sessionStorage.setItem(KEY, JSON.stringify(s));
|
|
297
|
+
} catch {
|
|
298
|
+
}
|
|
299
|
+
}
|
|
300
|
+
function clearDelegatedSession() {
|
|
301
|
+
try {
|
|
302
|
+
sessionStorage.removeItem(KEY);
|
|
303
|
+
} catch {
|
|
304
|
+
}
|
|
305
|
+
}
|
|
306
|
+
function readDelegatedCredential() {
|
|
307
|
+
const session = readDelegatedSession();
|
|
308
|
+
if (session) {
|
|
309
|
+
const { account, credential, deviceSecret } = session;
|
|
310
|
+
return { account, credential, deviceSecret };
|
|
311
|
+
}
|
|
312
|
+
if (typeof sessionStorage === "undefined") return null;
|
|
313
|
+
try {
|
|
314
|
+
const raw = sessionStorage.getItem(CREDENTIAL_KEY);
|
|
315
|
+
if (!raw) return null;
|
|
316
|
+
const parsed = JSON.parse(raw);
|
|
317
|
+
if (!parsed.account || !parsed.credential || !parsed.deviceSecret) return null;
|
|
318
|
+
return parsed;
|
|
319
|
+
} catch {
|
|
320
|
+
return null;
|
|
321
|
+
}
|
|
322
|
+
}
|
|
323
|
+
function saveDelegatedCredential(c) {
|
|
324
|
+
try {
|
|
325
|
+
sessionStorage.setItem(CREDENTIAL_KEY, JSON.stringify(c));
|
|
326
|
+
} catch {
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
function clearDelegatedCredential() {
|
|
330
|
+
try {
|
|
331
|
+
sessionStorage.removeItem(CREDENTIAL_KEY);
|
|
332
|
+
} catch {
|
|
333
|
+
}
|
|
334
|
+
}
|
|
335
|
+
function persistedNonces(relayUrl, contextId) {
|
|
336
|
+
const key = `calimero.nonce.${relayUrl}.${contextId ?? "no-context"}`;
|
|
337
|
+
return {
|
|
338
|
+
next: async () => {
|
|
339
|
+
let n = 0n;
|
|
340
|
+
try {
|
|
341
|
+
n = BigInt(localStorage.getItem(key) ?? "0");
|
|
342
|
+
} catch {
|
|
343
|
+
n = 0n;
|
|
344
|
+
}
|
|
345
|
+
try {
|
|
346
|
+
localStorage.setItem(key, String(n + 1n));
|
|
347
|
+
} catch {
|
|
348
|
+
}
|
|
349
|
+
return n;
|
|
350
|
+
}
|
|
351
|
+
};
|
|
352
|
+
}
|
|
353
|
+
function markContextNonceSpent(relayUrl, contextId, nonce) {
|
|
354
|
+
const key = `calimero.nonce.${relayUrl}.${contextId}`;
|
|
355
|
+
try {
|
|
356
|
+
const current = BigInt(localStorage.getItem(key) ?? "0");
|
|
357
|
+
if (current <= nonce) localStorage.setItem(key, String(nonce + 1n));
|
|
358
|
+
} catch {
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
var RELAY_NODE_KEY_PREFIX = "calimero.delegated.relay-node-key.";
|
|
362
|
+
function relayOrigin(relayUrl) {
|
|
363
|
+
return relayUrl.replace(/\/+$/, "");
|
|
364
|
+
}
|
|
365
|
+
function pinRelayNodeKey(relayUrl, nodeKey) {
|
|
366
|
+
localStorage.setItem(RELAY_NODE_KEY_PREFIX + relayOrigin(relayUrl), nodeKey.trim().toLowerCase());
|
|
367
|
+
}
|
|
368
|
+
function readPinnedRelayNodeKey(relayUrl) {
|
|
369
|
+
try {
|
|
370
|
+
const v = localStorage.getItem(RELAY_NODE_KEY_PREFIX + relayOrigin(relayUrl));
|
|
371
|
+
return v && /^[0-9a-f]{64}$/.test(v) ? v : null;
|
|
372
|
+
} catch {
|
|
373
|
+
return null;
|
|
374
|
+
}
|
|
375
|
+
}
|
|
376
|
+
function isLoopback(relayUrl) {
|
|
377
|
+
try {
|
|
378
|
+
const { hostname } = new URL(relayUrl);
|
|
379
|
+
return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
|
|
380
|
+
} catch {
|
|
381
|
+
return false;
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
var TRUSTED_RELAY_PROFILE = "locked-read-only";
|
|
385
|
+
var MIN_RELAY_RELEASE = "2.3.99";
|
|
386
|
+
var loadedDcap;
|
|
387
|
+
function relayQuoteVerifier(relayUrl) {
|
|
388
|
+
const verify = async (attestation) => {
|
|
389
|
+
loadedDcap ?? (loadedDcap = import('@phala/dcap-qvl').then(
|
|
390
|
+
({ verify: dcapVerify }) => dcapVerify,
|
|
391
|
+
(error) => {
|
|
392
|
+
loadedDcap = void 0;
|
|
393
|
+
throw error;
|
|
394
|
+
}
|
|
395
|
+
));
|
|
396
|
+
return meroJs.createSignedReleaseVerifier({
|
|
397
|
+
dcapVerify: await loadedDcap,
|
|
398
|
+
release: async () => meroJs.fetchNodeRelease(meroJs.cloudNodeReleaseUrl(meroJs.DEFAULT_RELEASE_MIRROR, await meroJs.fetchNodeReleaseVersion(relayUrl))),
|
|
399
|
+
profile: TRUSTED_RELAY_PROFILE,
|
|
400
|
+
minReleaseVersion: MIN_RELAY_RELEASE
|
|
401
|
+
})(attestation);
|
|
402
|
+
};
|
|
403
|
+
return Object.assign(verify, { includeCollateral: true });
|
|
404
|
+
}
|
|
405
|
+
async function resolveRelayNodeKey(relayUrl) {
|
|
406
|
+
const pinned = readPinnedRelayNodeKey(relayUrl);
|
|
407
|
+
if (pinned) return pinned;
|
|
408
|
+
try {
|
|
409
|
+
const local = isLoopback(relayUrl);
|
|
410
|
+
const { nodeKey } = await meroJs.attestRelayNodeKey({
|
|
411
|
+
relayUrl,
|
|
412
|
+
allowMock: local,
|
|
413
|
+
...local ? {} : { verify: relayQuoteVerifier(relayUrl) }
|
|
414
|
+
});
|
|
415
|
+
pinRelayNodeKey(relayUrl, nodeKey);
|
|
416
|
+
return nodeKey;
|
|
417
|
+
} catch (e) {
|
|
418
|
+
console.warn("[mero-react] could not learn the relay node key from its attestation", e);
|
|
419
|
+
return null;
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
function jwtExpiryMs(token) {
|
|
423
|
+
try {
|
|
424
|
+
const payload = JSON.parse(atob(token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
|
|
425
|
+
return typeof payload.exp === "number" ? payload.exp * 1e3 : null;
|
|
426
|
+
} catch {
|
|
427
|
+
return null;
|
|
428
|
+
}
|
|
429
|
+
}
|
|
430
|
+
function relaySession(s, nodeKey) {
|
|
431
|
+
let token = null;
|
|
432
|
+
let inflight = null;
|
|
433
|
+
return async () => {
|
|
434
|
+
const exp = token ? jwtExpiryMs(token) : null;
|
|
435
|
+
if (token && (exp === null || exp - Date.now() > 3e4)) return token;
|
|
436
|
+
if (!inflight) {
|
|
437
|
+
inflight = meroJs.login({
|
|
438
|
+
nodeUrl: s.relayUrl,
|
|
439
|
+
node: nodeKey,
|
|
440
|
+
deviceSecret: s.deviceSecret,
|
|
441
|
+
accountProof: s.credential,
|
|
442
|
+
audience: meroJs.defaultAudience()
|
|
443
|
+
}).then((minted) => {
|
|
444
|
+
token = minted.accessToken;
|
|
445
|
+
return token;
|
|
446
|
+
}).catch((e) => {
|
|
447
|
+
console.warn("[mero-react] relay login failed", e);
|
|
448
|
+
token = null;
|
|
449
|
+
return void 0;
|
|
450
|
+
}).finally(() => {
|
|
451
|
+
inflight = null;
|
|
452
|
+
});
|
|
453
|
+
}
|
|
454
|
+
return inflight;
|
|
455
|
+
};
|
|
456
|
+
}
|
|
457
|
+
function buildDelegatedClient(s, contextId) {
|
|
458
|
+
if (!s.relayUrl) return null;
|
|
459
|
+
const nodeKey = readPinnedRelayNodeKey(s.relayUrl);
|
|
460
|
+
return meroJs.createMeroClient({
|
|
461
|
+
transport: "relay",
|
|
462
|
+
relay: {
|
|
463
|
+
relayUrl: s.relayUrl,
|
|
464
|
+
authorAccount: s.account,
|
|
465
|
+
authorProof: s.credential,
|
|
466
|
+
deviceSecret: s.deviceSecret,
|
|
467
|
+
// The active context, passed in rather than stored on the record: the
|
|
468
|
+
// relay client holds ONE nonce source while `execute` takes a context per
|
|
469
|
+
// call, so the ledger has to be re-keyed when the chosen context changes.
|
|
470
|
+
nonces: persistedNonces(s.relayUrl, contextId)
|
|
471
|
+
},
|
|
472
|
+
// The certificate authenticates the requests too, not just the writes.
|
|
473
|
+
//
|
|
474
|
+
// This is the whole of what reads and events need: the device key signs each
|
|
475
|
+
// request, and the node verifies it against the account's certificate with no
|
|
476
|
+
// store read and no prior relationship. Measured against a node built from
|
|
477
|
+
// core `aecba573b`: `listNamespaces` and `getContexts` answer `200` and are
|
|
478
|
+
// caller-scoped, `/sse` answers `200`, and a real write arrives on the stream
|
|
479
|
+
// as a `StateMutation` frame.
|
|
480
|
+
//
|
|
481
|
+
// What this replaces is a session minted by `login()` plus the relay node's
|
|
482
|
+
// signing key learned out of band — two inputs, one of which the cloud does
|
|
483
|
+
// not publish, for an answer the certificate already gives.
|
|
484
|
+
proof: { credential: s.credential, deviceSecret: s.deviceSecret },
|
|
485
|
+
// A session, when this relay's node key is pinned. A hosted relay's
|
|
486
|
+
// forward-auth accepts a Bearer token and not the proof above, so without
|
|
487
|
+
// one every admin read there is a 401. Given a session the client uses it
|
|
488
|
+
// for every admin call; a relay with no pinned key keeps the proof path.
|
|
489
|
+
session: nodeKey ? relaySession({ ...s, relayUrl: s.relayUrl }, nodeKey) : void 0,
|
|
490
|
+
// Events too. `/sse` on a relay sits behind the same forward-auth, so the
|
|
491
|
+
// proof above gets a 401 there; with the node key the client observes
|
|
492
|
+
// through its own device-certificate login instead.
|
|
493
|
+
observe: nodeKey ? { nodeKey } : void 0
|
|
494
|
+
});
|
|
495
|
+
}
|
|
496
|
+
var RELAY_MAP_PREFIX = "calimero.delegated.relays.";
|
|
497
|
+
function readRelayMap(account) {
|
|
498
|
+
try {
|
|
499
|
+
const raw = localStorage.getItem(RELAY_MAP_PREFIX + account);
|
|
500
|
+
const parsed = raw ? JSON.parse(raw) : {};
|
|
501
|
+
return { namespaces: parsed.namespaces ?? {}, contexts: parsed.contexts ?? {} };
|
|
502
|
+
} catch {
|
|
503
|
+
return { namespaces: {}, contexts: {} };
|
|
504
|
+
}
|
|
505
|
+
}
|
|
506
|
+
function writeRelayMap(account, map) {
|
|
507
|
+
try {
|
|
508
|
+
localStorage.setItem(RELAY_MAP_PREFIX + account, JSON.stringify(map));
|
|
509
|
+
} catch {
|
|
510
|
+
}
|
|
511
|
+
}
|
|
512
|
+
function rememberRelay(account, relayUrl, at) {
|
|
513
|
+
const map = readRelayMap(account);
|
|
514
|
+
const url = relayOrigin(relayUrl);
|
|
515
|
+
if (at.namespaceId) map.namespaces[at.namespaceId] = url;
|
|
516
|
+
if (at.contextId) map.contexts[at.contextId] = url;
|
|
517
|
+
writeRelayMap(account, map);
|
|
518
|
+
}
|
|
519
|
+
function relayForContext(account, contextId) {
|
|
520
|
+
return readRelayMap(account).contexts[contextId] ?? null;
|
|
521
|
+
}
|
|
522
|
+
function knownRelays(s) {
|
|
523
|
+
const map = readRelayMap(s.account);
|
|
524
|
+
const all = [s.relayUrl, ...Object.values(map.namespaces), ...Object.values(map.contexts)].filter((u) => typeof u === "string" && u.length > 0).map(relayOrigin);
|
|
525
|
+
return [...new Set(all)];
|
|
526
|
+
}
|
|
527
|
+
async function listDelegatedContexts(s) {
|
|
528
|
+
const out = [];
|
|
529
|
+
const map = readRelayMap(s.account);
|
|
530
|
+
for (const relayUrl of knownRelays(s)) {
|
|
531
|
+
try {
|
|
532
|
+
if (!await resolveRelayNodeKey(relayUrl)) continue;
|
|
533
|
+
const client2 = buildDelegatedClient({ ...s, relayUrl }, null);
|
|
534
|
+
if (!client2) continue;
|
|
535
|
+
const { contexts } = await client2.admin.getContexts();
|
|
536
|
+
for (const c of contexts ?? []) {
|
|
537
|
+
out.push({ ...c, relayUrl });
|
|
538
|
+
map.contexts[c.id] = relayUrl;
|
|
539
|
+
}
|
|
540
|
+
} catch (e) {
|
|
541
|
+
console.warn(`[mero-react] could not list contexts on ${relayUrl}`, e);
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
writeRelayMap(s.account, map);
|
|
545
|
+
return out;
|
|
546
|
+
}
|
|
547
|
+
async function listDelegatedNamespaces(s) {
|
|
548
|
+
var _a, _b;
|
|
549
|
+
const out = [];
|
|
550
|
+
const seen = /* @__PURE__ */ new Set();
|
|
551
|
+
const map = readRelayMap(s.account);
|
|
552
|
+
for (const relayUrl of knownRelays(s)) {
|
|
553
|
+
try {
|
|
554
|
+
if (!await resolveRelayNodeKey(relayUrl)) continue;
|
|
555
|
+
const client2 = buildDelegatedClient({ ...s, relayUrl }, null);
|
|
556
|
+
if (!client2) continue;
|
|
557
|
+
for (const ns of await client2.admin.listNamespaces()) {
|
|
558
|
+
if (seen.has(ns.namespaceId)) continue;
|
|
559
|
+
seen.add(ns.namespaceId);
|
|
560
|
+
out.push({ ...ns, relayUrl });
|
|
561
|
+
(_a = map.namespaces)[_b = ns.namespaceId] ?? (_a[_b] = relayUrl);
|
|
562
|
+
}
|
|
563
|
+
} catch (e) {
|
|
564
|
+
console.warn(`[mero-react] could not list namespaces on ${relayUrl}`, e);
|
|
565
|
+
}
|
|
566
|
+
}
|
|
567
|
+
writeRelayMap(s.account, map);
|
|
568
|
+
return out;
|
|
569
|
+
}
|
|
283
570
|
var MeroContext = react.createContext(null);
|
|
284
571
|
var isBrowser = typeof window !== "undefined";
|
|
285
572
|
function getPermissionsForMode(mode) {
|
|
@@ -326,6 +613,9 @@ function MeroProvider({
|
|
|
326
613
|
[tokenStoreProp]
|
|
327
614
|
);
|
|
328
615
|
const [mero, setMero] = react.useState(null);
|
|
616
|
+
const [delegated, setDelegated] = react.useState(
|
|
617
|
+
() => readDelegatedSession()
|
|
618
|
+
);
|
|
329
619
|
const [isAuthenticated, setIsAuthenticated] = react.useState(false);
|
|
330
620
|
const [isOnline, setIsOnline] = react.useState(true);
|
|
331
621
|
const [isLoading, setIsLoading] = react.useState(true);
|
|
@@ -394,6 +684,12 @@ function MeroProvider({
|
|
|
394
684
|
},
|
|
395
685
|
[mode, packageName, packageVersion, registryUrl]
|
|
396
686
|
);
|
|
687
|
+
const connectWithAccount = react.useCallback((session) => {
|
|
688
|
+
saveDelegatedSession(session);
|
|
689
|
+
const { account, credential, deviceSecret } = session;
|
|
690
|
+
saveDelegatedCredential({ account, credential, deviceSecret });
|
|
691
|
+
setDelegated(session);
|
|
692
|
+
}, []);
|
|
397
693
|
const logout = react.useCallback(() => {
|
|
398
694
|
if (meroRef.current) {
|
|
399
695
|
meroRef.current.clearToken();
|
|
@@ -401,6 +697,9 @@ function MeroProvider({
|
|
|
401
697
|
}
|
|
402
698
|
tokenStore.clear();
|
|
403
699
|
clearAllStorage();
|
|
700
|
+
clearDelegatedSession();
|
|
701
|
+
clearDelegatedCredential();
|
|
702
|
+
setDelegated(null);
|
|
404
703
|
setMero(null);
|
|
405
704
|
setIsAuthenticated(false);
|
|
406
705
|
setNodeUrlState(null);
|
|
@@ -410,6 +709,44 @@ function MeroProvider({
|
|
|
410
709
|
meroRef.current = null;
|
|
411
710
|
}, [tokenStore]);
|
|
412
711
|
react.useEffect(() => {
|
|
712
|
+
if (!delegated) return;
|
|
713
|
+
const relayUrl = (contextId ? relayForContext(delegated.account, contextId) : null) ?? delegated.relayUrl;
|
|
714
|
+
const routed = { ...delegated, relayUrl };
|
|
715
|
+
const client2 = buildDelegatedClient(routed, contextId);
|
|
716
|
+
const awaitingKey = Boolean(client2 && relayUrl && !readPinnedRelayNodeKey(relayUrl));
|
|
717
|
+
if (!awaitingKey) setMero(client2);
|
|
718
|
+
setIsAuthenticated(true);
|
|
719
|
+
setIsOnline(true);
|
|
720
|
+
setNodeUrlState(relayUrl);
|
|
721
|
+
setIsLoading(awaitingKey);
|
|
722
|
+
let active = true;
|
|
723
|
+
(async () => {
|
|
724
|
+
if (!client2 || !relayUrl) return;
|
|
725
|
+
if (awaitingKey) {
|
|
726
|
+
const nodeKey = await resolveRelayNodeKey(relayUrl);
|
|
727
|
+
if (!active) return;
|
|
728
|
+
setMero(nodeKey ? buildDelegatedClient(routed, contextId) ?? client2 : client2);
|
|
729
|
+
setIsLoading(false);
|
|
730
|
+
if (!nodeKey) return;
|
|
731
|
+
}
|
|
732
|
+
try {
|
|
733
|
+
const contexts = await listDelegatedContexts(delegated);
|
|
734
|
+
const apps = [
|
|
735
|
+
...new Set((contexts ?? []).map((c) => c.applicationId).filter(Boolean))
|
|
736
|
+
];
|
|
737
|
+
if (!active) return;
|
|
738
|
+
if (apps.length === 1) {
|
|
739
|
+
setApplicationIdState(apps[0]);
|
|
740
|
+
}
|
|
741
|
+
} catch {
|
|
742
|
+
}
|
|
743
|
+
})();
|
|
744
|
+
return () => {
|
|
745
|
+
active = false;
|
|
746
|
+
};
|
|
747
|
+
}, [delegated, contextId]);
|
|
748
|
+
react.useEffect(() => {
|
|
749
|
+
if (delegated) return;
|
|
413
750
|
let active = true;
|
|
414
751
|
const init = async () => {
|
|
415
752
|
const callback = callbackRef.current;
|
|
@@ -487,7 +824,7 @@ function MeroProvider({
|
|
|
487
824
|
return () => {
|
|
488
825
|
active = false;
|
|
489
826
|
};
|
|
490
|
-
}, [createMeroInstance, checkAuth, allowedNodeUrls, tokenStore]);
|
|
827
|
+
}, [createMeroInstance, checkAuth, allowedNodeUrls, tokenStore, delegated]);
|
|
491
828
|
react.useEffect(() => {
|
|
492
829
|
if (!isAuthenticated || !meroRef.current) return;
|
|
493
830
|
let active = true;
|
|
@@ -498,6 +835,7 @@ function MeroProvider({
|
|
|
498
835
|
const onError = (err) => {
|
|
499
836
|
if (!active) return;
|
|
500
837
|
setIsOnline(false);
|
|
838
|
+
if (delegated) return;
|
|
501
839
|
if (err instanceof meroJs.AuthRevokedError) {
|
|
502
840
|
logout();
|
|
503
841
|
return;
|
|
@@ -541,7 +879,7 @@ function MeroProvider({
|
|
|
541
879
|
sse.off("connect", onConnect);
|
|
542
880
|
sse.off("error", onError);
|
|
543
881
|
};
|
|
544
|
-
}, [isAuthenticated, mero, checkAuth, logout]);
|
|
882
|
+
}, [isAuthenticated, mero, checkAuth, logout, delegated]);
|
|
545
883
|
const contextValue = react.useMemo(
|
|
546
884
|
() => ({
|
|
547
885
|
mero,
|
|
@@ -552,10 +890,14 @@ function MeroProvider({
|
|
|
552
890
|
contextId,
|
|
553
891
|
contextIdentity,
|
|
554
892
|
connectToNode,
|
|
893
|
+
connectWithAccount,
|
|
894
|
+
isDelegated: delegated !== null,
|
|
895
|
+
can: delegated !== null ? { createNamespace: Boolean(packageName), createContext: true, invite: false } : { createNamespace: true, createContext: true, invite: true },
|
|
896
|
+
app: { packageName, packageVersion, registryUrl },
|
|
555
897
|
logout,
|
|
556
898
|
isLoading
|
|
557
899
|
}),
|
|
558
|
-
[mero, isAuthenticated, isOnline, nodeUrl, applicationId, contextId, contextIdentity, connectToNode, logout, isLoading]
|
|
900
|
+
[mero, isAuthenticated, isOnline, nodeUrl, applicationId, contextId, contextIdentity, connectToNode, connectWithAccount, delegated, logout, isLoading, packageName, packageVersion, registryUrl]
|
|
559
901
|
);
|
|
560
902
|
return /* @__PURE__ */ jsxRuntime.jsx(MeroContext.Provider, { value: contextValue, children });
|
|
561
903
|
}
|
|
@@ -1287,6 +1629,314 @@ function ConnectButton({
|
|
|
1287
1629
|
}
|
|
1288
1630
|
);
|
|
1289
1631
|
}
|
|
1632
|
+
var DEVICE_KEY = "calimero.device";
|
|
1633
|
+
var STATE_KEY = "calimero.enrol.state";
|
|
1634
|
+
var HOSTED_WALLET = "https://wallet.cloud.calimero.network/account-enroll";
|
|
1635
|
+
var hex = (b) => [...new Uint8Array(b)].map((x) => x.toString(16).padStart(2, "0")).join("");
|
|
1636
|
+
function chooseRelay(relays) {
|
|
1637
|
+
const reachable = relays.filter(
|
|
1638
|
+
(r) => typeof r.relayUrl === "string" && r.relayUrl.length > 0
|
|
1639
|
+
);
|
|
1640
|
+
const fresh = reachable.find((r) => r.fresh);
|
|
1641
|
+
if (fresh) return { relayUrl: fresh.relayUrl, note: null };
|
|
1642
|
+
if (reachable.length > 0) {
|
|
1643
|
+
return {
|
|
1644
|
+
relayUrl: reachable[0].relayUrl,
|
|
1645
|
+
note: "Connected through a relay whose last heartbeat has lapsed \u2014 it may not answer. It was the only one with an address."
|
|
1646
|
+
};
|
|
1647
|
+
}
|
|
1648
|
+
if (relays.length > 0) {
|
|
1649
|
+
return {
|
|
1650
|
+
relayUrl: null,
|
|
1651
|
+
note: `Signed in. Your account has ${relays.length} relay${relays.length === 1 ? "" : "s"} assigned, but the cloud knows no address for any of them yet, so there is nowhere to write through for the moment. Reads and writes resume as soon as one reports in.`
|
|
1652
|
+
};
|
|
1653
|
+
}
|
|
1654
|
+
return {
|
|
1655
|
+
relayUrl: null,
|
|
1656
|
+
note: "Signed in, with nowhere to write yet: a new account is a member of nothing, so no node serves it. Redeeming an invitation admits this account to a namespace and gives it a relay \u2014 that is the normal first step, not an error."
|
|
1657
|
+
};
|
|
1658
|
+
}
|
|
1659
|
+
async function deviceKeys() {
|
|
1660
|
+
const had = localStorage.getItem(DEVICE_KEY);
|
|
1661
|
+
if (had) {
|
|
1662
|
+
const parsed = JSON.parse(had);
|
|
1663
|
+
if (parsed.kemSk && parsed.signSk && parsed.signPk && parsed.kemPk) {
|
|
1664
|
+
return parsed;
|
|
1665
|
+
}
|
|
1666
|
+
localStorage.removeItem(DEVICE_KEY);
|
|
1667
|
+
}
|
|
1668
|
+
const sign = await crypto.subtle.generateKey({ name: "Ed25519" }, true, [
|
|
1669
|
+
"sign",
|
|
1670
|
+
"verify"
|
|
1671
|
+
]);
|
|
1672
|
+
let agree;
|
|
1673
|
+
try {
|
|
1674
|
+
agree = await crypto.subtle.generateKey({ name: "X25519" }, true, [
|
|
1675
|
+
"deriveBits"
|
|
1676
|
+
]);
|
|
1677
|
+
} catch {
|
|
1678
|
+
throw new Error(
|
|
1679
|
+
"this browser cannot generate an X25519 key, so it cannot receive wrapped scope keys. Chrome 133+ and Safari 17+ support it; enrolling without one would certify a delivery key nothing holds the secret for."
|
|
1680
|
+
);
|
|
1681
|
+
}
|
|
1682
|
+
const keys = {
|
|
1683
|
+
signPk: hex(await crypto.subtle.exportKey("raw", sign.publicKey)),
|
|
1684
|
+
signSk: hex((await crypto.subtle.exportKey("pkcs8", sign.privateKey)).slice(16)),
|
|
1685
|
+
kemPk: hex(await crypto.subtle.exportKey("raw", agree.publicKey)),
|
|
1686
|
+
kemSk: hex((await crypto.subtle.exportKey("pkcs8", agree.privateKey)).slice(16))
|
|
1687
|
+
};
|
|
1688
|
+
localStorage.setItem(DEVICE_KEY, JSON.stringify(keys));
|
|
1689
|
+
return keys;
|
|
1690
|
+
}
|
|
1691
|
+
function ConnectButtonAccount({
|
|
1692
|
+
className,
|
|
1693
|
+
style,
|
|
1694
|
+
theme,
|
|
1695
|
+
defaults = {}
|
|
1696
|
+
}) {
|
|
1697
|
+
const { isAuthenticated, isOnline, nodeUrl, isDelegated, connectToNode, connectWithAccount, logout } = useMero();
|
|
1698
|
+
const [isDropdownOpen, setIsDropdownOpen] = react.useState(false);
|
|
1699
|
+
const [isNodeModalOpen, setIsNodeModalOpen] = react.useState(false);
|
|
1700
|
+
const [isAccountOpen, setIsAccountOpen] = react.useState(false);
|
|
1701
|
+
const [note, setNote] = react.useState(null);
|
|
1702
|
+
const dropdownRef = react.useRef(null);
|
|
1703
|
+
const walletUrl = defaults.walletUrl ?? HOSTED_WALLET;
|
|
1704
|
+
const resolvedTheme = react.useMemo(() => theme ? resolveMeroTheme(theme) : null, [theme]);
|
|
1705
|
+
const themeVars = react.useMemo(
|
|
1706
|
+
() => resolvedTheme ? themeToCssVars(resolvedTheme) : void 0,
|
|
1707
|
+
[resolvedTheme]
|
|
1708
|
+
);
|
|
1709
|
+
react.useEffect(() => {
|
|
1710
|
+
const onOutside = (e) => {
|
|
1711
|
+
if (dropdownRef.current && !dropdownRef.current.contains(e.target)) {
|
|
1712
|
+
setIsDropdownOpen(false);
|
|
1713
|
+
}
|
|
1714
|
+
};
|
|
1715
|
+
document.addEventListener("mousedown", onOutside);
|
|
1716
|
+
return () => document.removeEventListener("mousedown", onOutside);
|
|
1717
|
+
}, []);
|
|
1718
|
+
const callbackRef = react.useRef(void 0);
|
|
1719
|
+
const callbackErrorRef = react.useRef(null);
|
|
1720
|
+
if (callbackRef.current === void 0 && typeof window !== "undefined") {
|
|
1721
|
+
try {
|
|
1722
|
+
callbackRef.current = meroJs.readEnrolmentCallback();
|
|
1723
|
+
} catch (e) {
|
|
1724
|
+
callbackRef.current = null;
|
|
1725
|
+
callbackErrorRef.current = e instanceof Error ? e.message : String(e);
|
|
1726
|
+
}
|
|
1727
|
+
}
|
|
1728
|
+
const completingRef = react.useRef(false);
|
|
1729
|
+
react.useEffect(() => {
|
|
1730
|
+
if (callbackErrorRef.current) {
|
|
1731
|
+
setNote(callbackErrorRef.current);
|
|
1732
|
+
callbackErrorRef.current = null;
|
|
1733
|
+
return;
|
|
1734
|
+
}
|
|
1735
|
+
const back = callbackRef.current;
|
|
1736
|
+
if (!back || completingRef.current) return;
|
|
1737
|
+
completingRef.current = true;
|
|
1738
|
+
let cancelled = false;
|
|
1739
|
+
(async () => {
|
|
1740
|
+
try {
|
|
1741
|
+
const keys = await deviceKeys();
|
|
1742
|
+
const sent = (() => {
|
|
1743
|
+
try {
|
|
1744
|
+
return sessionStorage.getItem(STATE_KEY);
|
|
1745
|
+
} catch {
|
|
1746
|
+
return null;
|
|
1747
|
+
}
|
|
1748
|
+
})();
|
|
1749
|
+
try {
|
|
1750
|
+
sessionStorage.removeItem(STATE_KEY);
|
|
1751
|
+
} catch {
|
|
1752
|
+
}
|
|
1753
|
+
if (!sent) {
|
|
1754
|
+
setNote(
|
|
1755
|
+
'This enrolment could not be verified as one this tab started, so it was not accepted. Start again from "Enrol with your account".'
|
|
1756
|
+
);
|
|
1757
|
+
return;
|
|
1758
|
+
}
|
|
1759
|
+
const enrolled = await meroJs.completeDeviceEnrolment({
|
|
1760
|
+
...back,
|
|
1761
|
+
devicePublicKey: keys.signPk,
|
|
1762
|
+
kemPublicKey: keys.kemPk,
|
|
1763
|
+
expectState: sent
|
|
1764
|
+
});
|
|
1765
|
+
saveDelegatedCredential({
|
|
1766
|
+
account: enrolled.account,
|
|
1767
|
+
credential: enrolled.credential,
|
|
1768
|
+
deviceSecret: keys.signSk
|
|
1769
|
+
});
|
|
1770
|
+
const cloud = new meroJs.CloudClient({
|
|
1771
|
+
routingCredential: {
|
|
1772
|
+
credential: enrolled.credential,
|
|
1773
|
+
deviceSecret: keys.signSk
|
|
1774
|
+
}
|
|
1775
|
+
});
|
|
1776
|
+
const chosen = chooseRelay(await cloud.getAccountRelays(enrolled.account));
|
|
1777
|
+
if (chosen.note) setNote(chosen.note);
|
|
1778
|
+
connectWithAccount({
|
|
1779
|
+
relayUrl: chosen.relayUrl,
|
|
1780
|
+
account: enrolled.account,
|
|
1781
|
+
credential: enrolled.credential,
|
|
1782
|
+
deviceSecret: keys.signSk
|
|
1783
|
+
});
|
|
1784
|
+
} catch (e) {
|
|
1785
|
+
if (!cancelled) setNote(e instanceof Error ? e.message : String(e));
|
|
1786
|
+
}
|
|
1787
|
+
})();
|
|
1788
|
+
return () => {
|
|
1789
|
+
cancelled = true;
|
|
1790
|
+
};
|
|
1791
|
+
}, [connectWithAccount]);
|
|
1792
|
+
const goToWallet = react.useCallback(async () => {
|
|
1793
|
+
const keys = await deviceKeys();
|
|
1794
|
+
const state = hex(crypto.getRandomValues(new Uint8Array(16)));
|
|
1795
|
+
try {
|
|
1796
|
+
sessionStorage.setItem(STATE_KEY, state);
|
|
1797
|
+
} catch {
|
|
1798
|
+
}
|
|
1799
|
+
window.location.assign(
|
|
1800
|
+
meroJs.deviceEnrolmentUrl({
|
|
1801
|
+
walletUrl,
|
|
1802
|
+
devicePublicKey: keys.signPk,
|
|
1803
|
+
kemPublicKey: keys.kemPk,
|
|
1804
|
+
returnTo: window.location.origin + window.location.pathname,
|
|
1805
|
+
state
|
|
1806
|
+
})
|
|
1807
|
+
);
|
|
1808
|
+
}, [walletUrl]);
|
|
1809
|
+
if (isAuthenticated && !isOnline) {
|
|
1810
|
+
return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mero-connect-container", style: { ...themeVars, display: "inline-block" }, children: /* @__PURE__ */ jsxRuntime.jsxs(
|
|
1811
|
+
"button",
|
|
1812
|
+
{
|
|
1813
|
+
className: ["mero-connect-button", "mero-reconnecting", className].filter(Boolean).join(" "),
|
|
1814
|
+
style,
|
|
1815
|
+
disabled: true,
|
|
1816
|
+
"aria-label": "Reconnecting...",
|
|
1817
|
+
children: [
|
|
1818
|
+
/* @__PURE__ */ jsxRuntime.jsx(CalimeroLogo, { size: 18, className: "mero-logo" }),
|
|
1819
|
+
"Reconnecting..."
|
|
1820
|
+
]
|
|
1821
|
+
}
|
|
1822
|
+
) });
|
|
1823
|
+
}
|
|
1824
|
+
if (isAuthenticated) {
|
|
1825
|
+
return /* @__PURE__ */ jsxRuntime.jsxs(
|
|
1826
|
+
"div",
|
|
1827
|
+
{
|
|
1828
|
+
ref: dropdownRef,
|
|
1829
|
+
className: "mero-connect-container",
|
|
1830
|
+
style: { ...themeVars, position: "relative", display: "inline-block" },
|
|
1831
|
+
children: [
|
|
1832
|
+
/* @__PURE__ */ jsxRuntime.jsxs(
|
|
1833
|
+
"button",
|
|
1834
|
+
{
|
|
1835
|
+
className: ["mero-connect-button", "mero-connected", className].filter(Boolean).join(" "),
|
|
1836
|
+
style,
|
|
1837
|
+
onClick: () => setIsDropdownOpen((p) => !p),
|
|
1838
|
+
"aria-label": "Connected",
|
|
1839
|
+
children: [
|
|
1840
|
+
/* @__PURE__ */ jsxRuntime.jsx(CalimeroLogo, { size: 18, className: "mero-logo" }),
|
|
1841
|
+
isDelegated ? "Connected (account)" : "Connected"
|
|
1842
|
+
]
|
|
1843
|
+
}
|
|
1844
|
+
),
|
|
1845
|
+
isDropdownOpen && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mero-dropdown", children: [
|
|
1846
|
+
/* @__PURE__ */ jsxRuntime.jsx("div", { className: "mero-dropdown-info", title: nodeUrl || "", children: nodeUrl ?? (isDelegated ? "no relay yet" : null) }),
|
|
1847
|
+
!isDelegated && nodeUrl && /* @__PURE__ */ jsxRuntime.jsx(
|
|
1848
|
+
"a",
|
|
1849
|
+
{
|
|
1850
|
+
href: new URL("admin-dashboard/", nodeUrl).toString(),
|
|
1851
|
+
target: "_blank",
|
|
1852
|
+
rel: "noopener noreferrer",
|
|
1853
|
+
className: "mero-dropdown-item",
|
|
1854
|
+
children: "Dashboard"
|
|
1855
|
+
}
|
|
1856
|
+
),
|
|
1857
|
+
/* @__PURE__ */ jsxRuntime.jsx(
|
|
1858
|
+
"button",
|
|
1859
|
+
{
|
|
1860
|
+
className: "mero-dropdown-item",
|
|
1861
|
+
onClick: () => {
|
|
1862
|
+
setIsDropdownOpen(false);
|
|
1863
|
+
logout();
|
|
1864
|
+
},
|
|
1865
|
+
children: "Log out"
|
|
1866
|
+
}
|
|
1867
|
+
)
|
|
1868
|
+
] })
|
|
1869
|
+
]
|
|
1870
|
+
}
|
|
1871
|
+
);
|
|
1872
|
+
}
|
|
1873
|
+
return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mero-connect-container", style: { ...themeVars, display: "inline-block" }, children: [
|
|
1874
|
+
/* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", gap: 8, flexWrap: "wrap" }, children: [
|
|
1875
|
+
/* @__PURE__ */ jsxRuntime.jsxs(
|
|
1876
|
+
"button",
|
|
1877
|
+
{
|
|
1878
|
+
className: ["mero-connect-button", className].filter(Boolean).join(" "),
|
|
1879
|
+
style,
|
|
1880
|
+
onClick: () => setIsNodeModalOpen(true),
|
|
1881
|
+
children: [
|
|
1882
|
+
/* @__PURE__ */ jsxRuntime.jsx(CalimeroLogo, { size: 18, className: "mero-logo" }),
|
|
1883
|
+
"I run a node"
|
|
1884
|
+
]
|
|
1885
|
+
}
|
|
1886
|
+
),
|
|
1887
|
+
/* @__PURE__ */ jsxRuntime.jsx(
|
|
1888
|
+
"button",
|
|
1889
|
+
{
|
|
1890
|
+
className: ["mero-connect-button", className].filter(Boolean).join(" "),
|
|
1891
|
+
style,
|
|
1892
|
+
onClick: () => setIsAccountOpen((p) => !p),
|
|
1893
|
+
children: "I have an account"
|
|
1894
|
+
}
|
|
1895
|
+
)
|
|
1896
|
+
] }),
|
|
1897
|
+
isAccountOpen && /* @__PURE__ */ jsxRuntime.jsxs(
|
|
1898
|
+
"div",
|
|
1899
|
+
{
|
|
1900
|
+
style: {
|
|
1901
|
+
marginTop: 12,
|
|
1902
|
+
padding: 14,
|
|
1903
|
+
border: "1px solid rgba(127,127,127,.35)",
|
|
1904
|
+
borderRadius: 8,
|
|
1905
|
+
display: "grid",
|
|
1906
|
+
gap: 8,
|
|
1907
|
+
maxWidth: 520,
|
|
1908
|
+
textAlign: "left",
|
|
1909
|
+
font: "13px system-ui, sans-serif"
|
|
1910
|
+
},
|
|
1911
|
+
children: [
|
|
1912
|
+
/* @__PURE__ */ jsxRuntime.jsx("button", { className: "mero-connect-button", onClick: goToWallet, children: "Enrol with your account" }),
|
|
1913
|
+
/* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, opacity: 0.75 }, children: "You will approve a device key on the wallet's own page, then come back here. The relay never sees your account root \u2014 only the certificate it signed." }),
|
|
1914
|
+
/* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, opacity: 0.75 }, children: "That one certificate is all of it: finding the relay that serves your account, writing through it, reading your own contexts and namespaces, and live events. Nothing to paste in." }),
|
|
1915
|
+
defaults.walletUrl && /* Shown only when an app overrode it, so a local rig can see at a
|
|
1916
|
+
glance that it is not enrolling against the hosted wallet. */
|
|
1917
|
+
/* @__PURE__ */ jsxRuntime.jsxs("p", { style: { margin: 0, opacity: 0.6 }, children: [
|
|
1918
|
+
"Enrolling at ",
|
|
1919
|
+
/* @__PURE__ */ jsxRuntime.jsx("code", { children: walletUrl }),
|
|
1920
|
+
", not the hosted wallet."
|
|
1921
|
+
] })
|
|
1922
|
+
]
|
|
1923
|
+
}
|
|
1924
|
+
),
|
|
1925
|
+
note && /* @__PURE__ */ jsxRuntime.jsx("p", { style: { font: "13px system-ui, sans-serif", color: "#b3261e" }, children: note }),
|
|
1926
|
+
/* @__PURE__ */ jsxRuntime.jsx(
|
|
1927
|
+
LoginModal,
|
|
1928
|
+
{
|
|
1929
|
+
isOpen: isNodeModalOpen,
|
|
1930
|
+
onConnect: (url) => {
|
|
1931
|
+
setIsNodeModalOpen(false);
|
|
1932
|
+
connectToNode(url);
|
|
1933
|
+
},
|
|
1934
|
+
onClose: () => setIsNodeModalOpen(false),
|
|
1935
|
+
theme: resolvedTheme ?? theme
|
|
1936
|
+
}
|
|
1937
|
+
)
|
|
1938
|
+
] });
|
|
1939
|
+
}
|
|
1290
1940
|
|
|
1291
1941
|
// src/utils/base58.ts
|
|
1292
1942
|
var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
|
|
@@ -1308,6 +1958,159 @@ function base58ToHex(input) {
|
|
|
1308
1958
|
for (let k = 0; k < input.length && input[k] === "1"; k++) bytes.push(0);
|
|
1309
1959
|
return bytes.reverse().map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
1310
1960
|
}
|
|
1961
|
+
function governanceNonce(relay, group) {
|
|
1962
|
+
return { next: async () => nextGovernanceNonce(relay, group) };
|
|
1963
|
+
}
|
|
1964
|
+
function nextGovernanceNonce(relay, group) {
|
|
1965
|
+
const key = `calimero.governance-nonce.${relay}.${group}`;
|
|
1966
|
+
let last = 0n;
|
|
1967
|
+
try {
|
|
1968
|
+
last = BigInt(localStorage.getItem(key) ?? "0");
|
|
1969
|
+
} catch {
|
|
1970
|
+
}
|
|
1971
|
+
const next = [last + 1n, BigInt(Date.now())].reduce((a, b) => a > b ? a : b);
|
|
1972
|
+
try {
|
|
1973
|
+
localStorage.setItem(key, String(next));
|
|
1974
|
+
} catch {
|
|
1975
|
+
}
|
|
1976
|
+
return next;
|
|
1977
|
+
}
|
|
1978
|
+
function relayFor(s, namespaceId) {
|
|
1979
|
+
const url = readRelayMap(s.account).namespaces[namespaceId] ?? s.relayUrl;
|
|
1980
|
+
if (!url) throw new Error("no relay is known for this namespace, so there is nowhere to send this");
|
|
1981
|
+
return url.replace(/\/+$/, "");
|
|
1982
|
+
}
|
|
1983
|
+
function initArgsOf(params) {
|
|
1984
|
+
if (!params || params.length === 0) return {};
|
|
1985
|
+
return JSON.parse(new TextDecoder().decode(Uint8Array.from(params)));
|
|
1986
|
+
}
|
|
1987
|
+
function client(s, relayUrl, nonces, fetch2) {
|
|
1988
|
+
return new meroJs.RelayClient({
|
|
1989
|
+
relayUrl,
|
|
1990
|
+
authorAccount: s.account,
|
|
1991
|
+
authorProof: s.credential,
|
|
1992
|
+
deviceSecret: s.deviceSecret,
|
|
1993
|
+
nonces,
|
|
1994
|
+
fetch: fetch2
|
|
1995
|
+
});
|
|
1996
|
+
}
|
|
1997
|
+
async function createDelegatedContext(s, req, deps = {}) {
|
|
1998
|
+
const relay = relayFor(s, req.namespaceId);
|
|
1999
|
+
const creationNonce = 0n;
|
|
2000
|
+
const created = await client(s, relay, { next: async () => creationNonce }, deps.fetch).createContext({
|
|
2001
|
+
groupId: req.groupId ?? req.namespaceId,
|
|
2002
|
+
applicationId: req.applicationId,
|
|
2003
|
+
initArgs: initArgsOf(req.initializationParams),
|
|
2004
|
+
name: req.name
|
|
2005
|
+
});
|
|
2006
|
+
markContextNonceSpent(relay, created.contextId, creationNonce);
|
|
2007
|
+
rememberRelay(s.account, relay, { namespaceId: req.namespaceId, contextId: created.contextId });
|
|
2008
|
+
return { contextId: created.contextId };
|
|
2009
|
+
}
|
|
2010
|
+
async function delegatedGovernance(s, req, deps = {}) {
|
|
2011
|
+
const relay = relayFor(s, req.namespaceId);
|
|
2012
|
+
return client(s, relay, governanceNonce(relay, req.group), deps.fetch).govern({ groupId: req.group, op: req.op });
|
|
2013
|
+
}
|
|
2014
|
+
async function createDelegatedPrivateContext(s, req, deps = {}) {
|
|
2015
|
+
const { groupId } = await delegatedGovernance(
|
|
2016
|
+
s,
|
|
2017
|
+
{
|
|
2018
|
+
namespaceId: req.namespaceId,
|
|
2019
|
+
group: req.namespaceId,
|
|
2020
|
+
// The id is derived from a fresh salt (core#4244); a node refuses any other.
|
|
2021
|
+
op: (await meroJs.subgroupCreation({ parentId: req.namespaceId, restricted: true, admin: s.account })).op
|
|
2022
|
+
},
|
|
2023
|
+
deps
|
|
2024
|
+
);
|
|
2025
|
+
for (const member of req.members) {
|
|
2026
|
+
await delegatedGovernance(s, { namespaceId: req.namespaceId, group: groupId, op: meroJs.memberAddedOp(member, "Member") }, deps);
|
|
2027
|
+
}
|
|
2028
|
+
const { contextId } = await createDelegatedContext(s, { ...req, groupId }, deps);
|
|
2029
|
+
return { contextId, groupId };
|
|
2030
|
+
}
|
|
2031
|
+
async function foundDelegatedNamespace(s, req = {}, deps = {}) {
|
|
2032
|
+
const relays = knownRelays(s).map((u) => u.replace(/\/+$/, ""));
|
|
2033
|
+
const relay = relays[0];
|
|
2034
|
+
if (!relay) throw new Error("no relay is known for this account, so there is nowhere to found a namespace");
|
|
2035
|
+
const known = Object.entries(readRelayMap(s.account).namespaces).find(
|
|
2036
|
+
([, url]) => url.replace(/\/+$/, "") === relay
|
|
2037
|
+
)?.[0];
|
|
2038
|
+
if (!known) {
|
|
2039
|
+
throw new Error("join a namespace on this relay first: its executor account is learned from one you are in");
|
|
2040
|
+
}
|
|
2041
|
+
const { executorAccount } = await client(s, relay, governanceNonce(relay, known), deps.fetch).describeGovernance(known);
|
|
2042
|
+
let next = BigInt(Date.now());
|
|
2043
|
+
const founded = await client(s, relay, { next: async () => next++ }, deps.fetch).foundNamespace({
|
|
2044
|
+
executorAccount,
|
|
2045
|
+
...req.defaultCapabilities !== void 0 ? { defaultCapabilities: req.defaultCapabilities } : {},
|
|
2046
|
+
...req.application ? { application: req.application } : {}
|
|
2047
|
+
});
|
|
2048
|
+
try {
|
|
2049
|
+
localStorage.setItem(`calimero.governance-nonce.${relay}.${founded.namespaceId}`, String(next));
|
|
2050
|
+
} catch {
|
|
2051
|
+
}
|
|
2052
|
+
rememberRelay(s.account, relay, { namespaceId: founded.namespaceId });
|
|
2053
|
+
if (req.application && founded.applicationSet !== true) {
|
|
2054
|
+
throw new Error(
|
|
2055
|
+
`founded ${founded.namespaceId} but could not give it its application: ${founded.applicationError ?? "unknown reason"}`
|
|
2056
|
+
);
|
|
2057
|
+
}
|
|
2058
|
+
return { namespaceId: founded.namespaceId, teeEnabled: founded.teeEnabled };
|
|
2059
|
+
}
|
|
2060
|
+
async function latestPublishedVersion(registryUrl, pkg, fetchFn = globalThis.fetch) {
|
|
2061
|
+
const url = `${registryUrl.replace(/\/+$/, "")}/api/v2/bundles?package=${encodeURIComponent(pkg)}`;
|
|
2062
|
+
const response = await fetchFn(url, { headers: { Accept: "application/json" } });
|
|
2063
|
+
if (!response.ok) throw new Error(`the registry has no ${pkg} (HTTP ${response.status})`);
|
|
2064
|
+
const bundles = await response.json();
|
|
2065
|
+
const newer = (a, b) => {
|
|
2066
|
+
const [x, y] = [a, b].map((v) => v.split(/[.-]/).map((n) => Number.parseInt(n, 10) || 0));
|
|
2067
|
+
for (let i = 0; i < Math.max(x.length, y.length); i++) {
|
|
2068
|
+
if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
|
|
2069
|
+
}
|
|
2070
|
+
return false;
|
|
2071
|
+
};
|
|
2072
|
+
const latest = bundles.map((b) => b.appVersion).filter((v) => typeof v === "string" && v.length > 0).reduce((best, v) => !best || newer(v, best) ? v : best, void 0);
|
|
2073
|
+
if (!latest) throw new Error(`the registry lists no version of ${pkg}`);
|
|
2074
|
+
return latest;
|
|
2075
|
+
}
|
|
2076
|
+
|
|
2077
|
+
// src/delegated/govern.ts
|
|
2078
|
+
var GROUP_NAMESPACE_PREFIX = "calimero.delegated.group-namespace.";
|
|
2079
|
+
function readGroupNamespaces(account) {
|
|
2080
|
+
try {
|
|
2081
|
+
return JSON.parse(localStorage.getItem(GROUP_NAMESPACE_PREFIX + account) ?? "{}");
|
|
2082
|
+
} catch {
|
|
2083
|
+
return {};
|
|
2084
|
+
}
|
|
2085
|
+
}
|
|
2086
|
+
function rememberGroupNamespace(account, groupId, namespaceId) {
|
|
2087
|
+
try {
|
|
2088
|
+
const all = readGroupNamespaces(account);
|
|
2089
|
+
all[groupId] = namespaceId;
|
|
2090
|
+
localStorage.setItem(GROUP_NAMESPACE_PREFIX + account, JSON.stringify(all));
|
|
2091
|
+
} catch {
|
|
2092
|
+
}
|
|
2093
|
+
}
|
|
2094
|
+
function namespaceOfGroup(s, groupId) {
|
|
2095
|
+
if (readRelayMap(s.account).namespaces[groupId]) return groupId;
|
|
2096
|
+
return readGroupNamespaces(s.account)[groupId];
|
|
2097
|
+
}
|
|
2098
|
+
function requireNamespace(s, groupId) {
|
|
2099
|
+
const ns = namespaceOfGroup(s, groupId);
|
|
2100
|
+
if (!ns) {
|
|
2101
|
+
throw new Error(
|
|
2102
|
+
`the namespace of group ${groupId} is not known to this account: it can manage only groups in namespaces it joined or subgroups it created`
|
|
2103
|
+
);
|
|
2104
|
+
}
|
|
2105
|
+
return ns;
|
|
2106
|
+
}
|
|
2107
|
+
async function governGroup(s, groupId, op) {
|
|
2108
|
+
return delegatedGovernance(s, { namespaceId: requireNamespace(s, groupId), group: groupId, op });
|
|
2109
|
+
}
|
|
2110
|
+
async function governRoot(s, groupId, op) {
|
|
2111
|
+
const namespaceId = requireNamespace(s, groupId);
|
|
2112
|
+
return delegatedGovernance(s, { namespaceId, group: namespaceId, op });
|
|
2113
|
+
}
|
|
1311
2114
|
|
|
1312
2115
|
// src/hooks/index.ts
|
|
1313
2116
|
var NO_EPHEMERAL_SURFACE_MESSAGE = "useEphemeral: this client has no `mero.ephemeral` surface. Ephemeral presence requires @calimero-network/mero-js >= 9.1.0; upgrade the installed @calimero-network/mero-js (and any lockfile pin) to use it.";
|
|
@@ -1508,23 +2311,26 @@ function useMountedRef() {
|
|
|
1508
2311
|
}, []);
|
|
1509
2312
|
return mountedRef;
|
|
1510
2313
|
}
|
|
1511
|
-
function useAsyncMutation() {
|
|
2314
|
+
function useAsyncMutation({ throwOnError = false } = {}) {
|
|
1512
2315
|
const mountedRef = useMountedRef();
|
|
1513
2316
|
const [loading, setLoading] = react.useState(false);
|
|
1514
2317
|
const [error, setError] = react.useState(null);
|
|
2318
|
+
const [failure, setFailure] = react.useState(null);
|
|
1515
2319
|
const run = react.useCallback(
|
|
1516
2320
|
async (action) => {
|
|
1517
2321
|
if (mountedRef.current) {
|
|
1518
2322
|
setLoading(true);
|
|
1519
2323
|
setError(null);
|
|
2324
|
+
setFailure(null);
|
|
1520
2325
|
}
|
|
1521
2326
|
try {
|
|
1522
2327
|
return await action();
|
|
1523
2328
|
} catch (err) {
|
|
1524
|
-
const errorValue = toError(err);
|
|
1525
2329
|
if (mountedRef.current) {
|
|
1526
|
-
setError(
|
|
2330
|
+
setError(toError(err));
|
|
2331
|
+
setFailure(meroJs.classifyError(err));
|
|
1527
2332
|
}
|
|
2333
|
+
if (throwOnError) throw err;
|
|
1528
2334
|
return null;
|
|
1529
2335
|
} finally {
|
|
1530
2336
|
if (mountedRef.current) {
|
|
@@ -1532,9 +2338,9 @@ function useAsyncMutation() {
|
|
|
1532
2338
|
}
|
|
1533
2339
|
}
|
|
1534
2340
|
},
|
|
1535
|
-
[mountedRef]
|
|
2341
|
+
[mountedRef, throwOnError]
|
|
1536
2342
|
);
|
|
1537
|
-
return { loading, error, run, setError };
|
|
2343
|
+
return { loading, error, failure, run, setError };
|
|
1538
2344
|
}
|
|
1539
2345
|
function useAsyncResource(fetcher, initialValue, deps) {
|
|
1540
2346
|
const mountedRef = useMountedRef();
|
|
@@ -1602,7 +2408,7 @@ function extractAliasContextId(value) {
|
|
|
1602
2408
|
return null;
|
|
1603
2409
|
}
|
|
1604
2410
|
function useExecute(contextId, executorId) {
|
|
1605
|
-
const { mero } = useMero();
|
|
2411
|
+
const { mero, isDelegated } = useMero();
|
|
1606
2412
|
const [loading, setLoading] = react.useState(false);
|
|
1607
2413
|
const [error, setError] = react.useState(null);
|
|
1608
2414
|
const mountedRef = react.useRef(true);
|
|
@@ -1615,7 +2421,13 @@ function useExecute(contextId, executorId) {
|
|
|
1615
2421
|
const execute = react.useCallback(
|
|
1616
2422
|
async (method, params) => {
|
|
1617
2423
|
if (!mero || !contextId || !executorId) {
|
|
1618
|
-
if (mountedRef.current)
|
|
2424
|
+
if (mountedRef.current) {
|
|
2425
|
+
setError(
|
|
2426
|
+
new Error(
|
|
2427
|
+
!mero && isDelegated ? "No relay for this account yet, so there is nowhere to send this write. Redeeming an invitation admits the account to a namespace and gives it a relay; reads and events resume with it." : "Not connected"
|
|
2428
|
+
)
|
|
2429
|
+
);
|
|
2430
|
+
}
|
|
1619
2431
|
return null;
|
|
1620
2432
|
}
|
|
1621
2433
|
if (mountedRef.current) {
|
|
@@ -1638,7 +2450,7 @@ function useExecute(contextId, executorId) {
|
|
|
1638
2450
|
if (mountedRef.current) setLoading(false);
|
|
1639
2451
|
}
|
|
1640
2452
|
},
|
|
1641
|
-
[mero, contextId, executorId]
|
|
2453
|
+
[mero, contextId, executorId, isDelegated]
|
|
1642
2454
|
);
|
|
1643
2455
|
return { execute, loading, error };
|
|
1644
2456
|
}
|
|
@@ -1666,14 +2478,22 @@ function useSubscription(input, callback) {
|
|
|
1666
2478
|
}, [mero, contextIdsKey, groupIdsKey]);
|
|
1667
2479
|
}
|
|
1668
2480
|
function useContexts(applicationId) {
|
|
1669
|
-
const { mero } = useMero();
|
|
2481
|
+
const { mero, isDelegated } = useMero();
|
|
1670
2482
|
const { data, loading, error, refetch } = useAsyncResource(
|
|
1671
2483
|
mero ? async () => {
|
|
2484
|
+
if (isDelegated) {
|
|
2485
|
+
const session = readDelegatedSession();
|
|
2486
|
+
const listed = session ? await listDelegatedContexts(session) : [];
|
|
2487
|
+
const own = listed.filter(
|
|
2488
|
+
(c) => !applicationId || c.applicationId === applicationId
|
|
2489
|
+
);
|
|
2490
|
+
return mapApplicationContexts(own);
|
|
2491
|
+
}
|
|
1672
2492
|
const response = applicationId ? await mero.admin.getContextsForApplication(applicationId) : await mero.admin.getContexts();
|
|
1673
2493
|
return mapApplicationContexts(response.contexts ?? []);
|
|
1674
2494
|
} : null,
|
|
1675
2495
|
[],
|
|
1676
|
-
[mero, applicationId]
|
|
2496
|
+
[mero, applicationId, isDelegated]
|
|
1677
2497
|
);
|
|
1678
2498
|
return { contexts: data, loading, error, refetch };
|
|
1679
2499
|
}
|
|
@@ -1905,17 +2725,58 @@ function useContextDiscovery(options) {
|
|
|
1905
2725
|
return { context, loading, error, discover, reset };
|
|
1906
2726
|
}
|
|
1907
2727
|
function useCreateContext() {
|
|
1908
|
-
const { mero } = useMero();
|
|
2728
|
+
const { mero, isDelegated } = useMero();
|
|
1909
2729
|
const { loading, error, run } = useAsyncMutation();
|
|
1910
2730
|
const createContext2 = react.useCallback(
|
|
1911
2731
|
async (request) => {
|
|
2732
|
+
if (isDelegated) {
|
|
2733
|
+
const session = readDelegatedSession();
|
|
2734
|
+
if (!session || !request.groupId) return null;
|
|
2735
|
+
return run(
|
|
2736
|
+
() => createDelegatedContext(session, {
|
|
2737
|
+
namespaceId: request.groupId,
|
|
2738
|
+
applicationId: request.applicationId,
|
|
2739
|
+
initializationParams: request.initializationParams
|
|
2740
|
+
})
|
|
2741
|
+
);
|
|
2742
|
+
}
|
|
1912
2743
|
if (!mero) return null;
|
|
1913
2744
|
return run(() => mero.admin.createContext(request));
|
|
1914
2745
|
},
|
|
1915
|
-
[mero, run]
|
|
2746
|
+
[mero, run, isDelegated]
|
|
1916
2747
|
);
|
|
1917
2748
|
return { createContext: createContext2, loading, error };
|
|
1918
2749
|
}
|
|
2750
|
+
function useCreatePrivateContext() {
|
|
2751
|
+
const { mero, isDelegated } = useMero();
|
|
2752
|
+
const { loading, error, run } = useAsyncMutation();
|
|
2753
|
+
const createPrivateContext = react.useCallback(
|
|
2754
|
+
async (request) => {
|
|
2755
|
+
if (isDelegated) {
|
|
2756
|
+
const session = readDelegatedSession();
|
|
2757
|
+
if (!session) return null;
|
|
2758
|
+
return run(() => createDelegatedPrivateContext(session, request));
|
|
2759
|
+
}
|
|
2760
|
+
if (!mero) return null;
|
|
2761
|
+
return run(async () => {
|
|
2762
|
+
const { groupId } = await mero.admin.createGroupInNamespace(request.namespaceId, {
|
|
2763
|
+
visibility: "restricted"
|
|
2764
|
+
});
|
|
2765
|
+
await mero.admin.addGroupMembers(groupId, {
|
|
2766
|
+
members: request.members.map((identity) => ({ identity, role: "Member" }))
|
|
2767
|
+
});
|
|
2768
|
+
const { contextId } = await mero.admin.createContext({
|
|
2769
|
+
applicationId: request.applicationId,
|
|
2770
|
+
groupId,
|
|
2771
|
+
initializationParams: request.initializationParams
|
|
2772
|
+
});
|
|
2773
|
+
return { contextId };
|
|
2774
|
+
});
|
|
2775
|
+
},
|
|
2776
|
+
[mero, run, isDelegated]
|
|
2777
|
+
);
|
|
2778
|
+
return { createPrivateContext, loading, error };
|
|
2779
|
+
}
|
|
1919
2780
|
function useDeleteContext() {
|
|
1920
2781
|
const { mero } = useMero();
|
|
1921
2782
|
const { loading, error, run } = useAsyncMutation();
|
|
@@ -1928,9 +2789,9 @@ function useDeleteContext() {
|
|
|
1928
2789
|
);
|
|
1929
2790
|
return { deleteContext, loading, error };
|
|
1930
2791
|
}
|
|
1931
|
-
function useJoinContext() {
|
|
2792
|
+
function useJoinContext(options = {}) {
|
|
1932
2793
|
const { mero } = useMero();
|
|
1933
|
-
const { loading, error, run } = useAsyncMutation();
|
|
2794
|
+
const { loading, error, failure, run } = useAsyncMutation(options);
|
|
1934
2795
|
const joinContext = react.useCallback(
|
|
1935
2796
|
async (contextId) => {
|
|
1936
2797
|
if (!mero) return null;
|
|
@@ -1938,17 +2799,26 @@ function useJoinContext() {
|
|
|
1938
2799
|
},
|
|
1939
2800
|
[mero, run]
|
|
1940
2801
|
);
|
|
1941
|
-
return { joinContext, loading, error };
|
|
2802
|
+
return { joinContext, loading, error, failure };
|
|
1942
2803
|
}
|
|
1943
2804
|
function useJoinSubgroupInheritance() {
|
|
1944
|
-
const { mero } = useMero();
|
|
2805
|
+
const { mero, isDelegated } = useMero();
|
|
1945
2806
|
const { loading, error, run } = useAsyncMutation();
|
|
1946
2807
|
const joinSubgroupInheritance = react.useCallback(
|
|
1947
2808
|
async (groupId) => {
|
|
2809
|
+
if (isDelegated) {
|
|
2810
|
+
const session = readDelegatedSession();
|
|
2811
|
+
if (!session) return null;
|
|
2812
|
+
return run(async () => {
|
|
2813
|
+
await governRoot(session, groupId, meroJs.memberJoinedOpenOp({ member: session.account, groupId, credential: session.credential }));
|
|
2814
|
+
const { publicKey } = await meroJs.signerFromSecret(session.deviceSecret);
|
|
2815
|
+
return { groupId, memberPublicKey: publicKey, wasInherited: false };
|
|
2816
|
+
});
|
|
2817
|
+
}
|
|
1948
2818
|
if (!mero) return null;
|
|
1949
2819
|
return run(() => mero.admin.joinSubgroupInheritance(groupId));
|
|
1950
2820
|
},
|
|
1951
|
-
[mero, run]
|
|
2821
|
+
[mero, run, isDelegated]
|
|
1952
2822
|
);
|
|
1953
2823
|
return { joinSubgroupInheritance, loading, error };
|
|
1954
2824
|
}
|
|
@@ -1971,14 +2841,19 @@ function useGroupInfo(groupId) {
|
|
|
1971
2841
|
return { groupInfo: data, loading, error, refetch };
|
|
1972
2842
|
}
|
|
1973
2843
|
function useDeleteGroup() {
|
|
1974
|
-
const { mero } = useMero();
|
|
2844
|
+
const { mero, isDelegated } = useMero();
|
|
1975
2845
|
const { loading, error, run } = useAsyncMutation();
|
|
1976
2846
|
const deleteGroup = react.useCallback(
|
|
1977
2847
|
async (groupId) => {
|
|
2848
|
+
if (isDelegated) {
|
|
2849
|
+
const session = readDelegatedSession();
|
|
2850
|
+
if (!session) return null;
|
|
2851
|
+
return run(() => governRoot(session, groupId, meroJs.groupDeletedOp(groupId)));
|
|
2852
|
+
}
|
|
1978
2853
|
if (!mero) return null;
|
|
1979
2854
|
return run(() => mero.admin.deleteGroup(groupId));
|
|
1980
2855
|
},
|
|
1981
|
-
[mero, run]
|
|
2856
|
+
[mero, run, isDelegated]
|
|
1982
2857
|
);
|
|
1983
2858
|
return { deleteGroup, loading, error };
|
|
1984
2859
|
}
|
|
@@ -1995,26 +2870,42 @@ function useSyncGroup() {
|
|
|
1995
2870
|
return { syncGroup, loading, error };
|
|
1996
2871
|
}
|
|
1997
2872
|
function useAddGroupMembers() {
|
|
1998
|
-
const { mero } = useMero();
|
|
2873
|
+
const { mero, isDelegated } = useMero();
|
|
1999
2874
|
const { loading, error, run } = useAsyncMutation();
|
|
2000
2875
|
const addGroupMembers = react.useCallback(
|
|
2001
2876
|
async (groupId, request) => {
|
|
2877
|
+
if (isDelegated) {
|
|
2878
|
+
const session = readDelegatedSession();
|
|
2879
|
+
if (!session) return null;
|
|
2880
|
+
return run(async () => {
|
|
2881
|
+
for (const m of request.members) {
|
|
2882
|
+
await governGroup(session, groupId, meroJs.memberAddedOp(m.identity, m.role));
|
|
2883
|
+
}
|
|
2884
|
+
});
|
|
2885
|
+
}
|
|
2002
2886
|
if (!mero) return null;
|
|
2003
2887
|
return run(() => mero.admin.addGroupMembers(groupId, request));
|
|
2004
2888
|
},
|
|
2005
|
-
[mero, run]
|
|
2889
|
+
[mero, run, isDelegated]
|
|
2006
2890
|
);
|
|
2007
2891
|
return { addGroupMembers, loading, error };
|
|
2008
2892
|
}
|
|
2009
2893
|
function useRemoveGroupMembers() {
|
|
2010
|
-
const { mero } = useMero();
|
|
2894
|
+
const { mero, isDelegated } = useMero();
|
|
2011
2895
|
const { loading, error, run } = useAsyncMutation();
|
|
2012
2896
|
const removeGroupMembers = react.useCallback(
|
|
2013
2897
|
async (groupId, request) => {
|
|
2898
|
+
if (isDelegated) {
|
|
2899
|
+
const session = readDelegatedSession();
|
|
2900
|
+
if (!session) return null;
|
|
2901
|
+
return run(async () => {
|
|
2902
|
+
for (const member of request.members) await governGroup(session, groupId, meroJs.memberRemovedOp(member));
|
|
2903
|
+
});
|
|
2904
|
+
}
|
|
2014
2905
|
if (!mero) return null;
|
|
2015
2906
|
return run(() => mero.admin.removeGroupMembers(groupId, request));
|
|
2016
2907
|
},
|
|
2017
|
-
[mero, run]
|
|
2908
|
+
[mero, run, isDelegated]
|
|
2018
2909
|
);
|
|
2019
2910
|
return { removeGroupMembers, loading, error };
|
|
2020
2911
|
}
|
|
@@ -2055,23 +2946,43 @@ function useNamespaceIdentity(namespaceId) {
|
|
|
2055
2946
|
return { identity: data, loading, error, refetch };
|
|
2056
2947
|
}
|
|
2057
2948
|
function useNamespacesForApplication(applicationId) {
|
|
2058
|
-
const { mero } = useMero();
|
|
2949
|
+
const { mero, isDelegated } = useMero();
|
|
2059
2950
|
const { data, loading, error, refetch } = useAsyncResource(
|
|
2060
|
-
mero && applicationId ?
|
|
2951
|
+
mero && applicationId ? isDelegated ? async () => {
|
|
2952
|
+
const session = readDelegatedSession();
|
|
2953
|
+
const listed = session ? await listDelegatedNamespaces(session) : [];
|
|
2954
|
+
return listed.filter((ns) => ns.targetApplicationId === applicationId);
|
|
2955
|
+
} : () => mero.admin.listNamespacesForApplication(applicationId) : null,
|
|
2061
2956
|
[],
|
|
2062
|
-
[mero, applicationId]
|
|
2957
|
+
[mero, applicationId, isDelegated]
|
|
2063
2958
|
);
|
|
2064
2959
|
return { namespaces: data, loading, error, refetch };
|
|
2065
2960
|
}
|
|
2961
|
+
var DEFAULT_REGISTRY_URL = "https://apps.calimero.network";
|
|
2066
2962
|
function useCreateNamespace() {
|
|
2067
|
-
const { mero } = useMero();
|
|
2963
|
+
const { mero, isDelegated, app } = useMero();
|
|
2068
2964
|
const { loading, error, run } = useAsyncMutation();
|
|
2069
2965
|
const createNamespace = react.useCallback(
|
|
2070
2966
|
async (request) => {
|
|
2967
|
+
if (isDelegated) {
|
|
2968
|
+
const session = readDelegatedSession();
|
|
2969
|
+
if (!session) return null;
|
|
2970
|
+
const pkg = app.packageName;
|
|
2971
|
+
return run(async () => {
|
|
2972
|
+
if (!pkg) {
|
|
2973
|
+
throw new Error("this app names no registry package, so a founded namespace could not be given its application");
|
|
2974
|
+
}
|
|
2975
|
+
const version = app.packageVersion ?? await latestPublishedVersion(app.registryUrl ?? DEFAULT_REGISTRY_URL, pkg);
|
|
2976
|
+
return foundDelegatedNamespace(session, {
|
|
2977
|
+
defaultCapabilities: 231,
|
|
2978
|
+
application: { applicationId: request.applicationId, package: pkg, version }
|
|
2979
|
+
});
|
|
2980
|
+
});
|
|
2981
|
+
}
|
|
2071
2982
|
if (!mero) return null;
|
|
2072
2983
|
return run(() => mero.admin.createNamespace(request));
|
|
2073
2984
|
},
|
|
2074
|
-
[mero, run]
|
|
2985
|
+
[mero, run, isDelegated, app]
|
|
2075
2986
|
);
|
|
2076
2987
|
return { createNamespace, loading, error };
|
|
2077
2988
|
}
|
|
@@ -2099,9 +3010,9 @@ function useCreateNamespaceInvitation() {
|
|
|
2099
3010
|
);
|
|
2100
3011
|
return { createNamespaceInvitation, loading, error };
|
|
2101
3012
|
}
|
|
2102
|
-
function useJoinNamespace() {
|
|
3013
|
+
function useJoinNamespace(options = {}) {
|
|
2103
3014
|
const { mero } = useMero();
|
|
2104
|
-
const { loading, error, run } = useAsyncMutation();
|
|
3015
|
+
const { loading, error, failure, run } = useAsyncMutation(options);
|
|
2105
3016
|
const joinNamespace = react.useCallback(
|
|
2106
3017
|
async (namespaceId, request) => {
|
|
2107
3018
|
if (!mero) return null;
|
|
@@ -2109,17 +3020,59 @@ function useJoinNamespace() {
|
|
|
2109
3020
|
},
|
|
2110
3021
|
[mero, run]
|
|
2111
3022
|
);
|
|
2112
|
-
return { joinNamespace, loading, error };
|
|
3023
|
+
return { joinNamespace, loading, error, failure };
|
|
2113
3024
|
}
|
|
2114
|
-
function
|
|
3025
|
+
function useRedeemInvitation() {
|
|
2115
3026
|
const { mero } = useMero();
|
|
3027
|
+
const mountedRef = useMountedRef();
|
|
3028
|
+
const [loading, setLoading] = react.useState(false);
|
|
3029
|
+
const [outcome, setOutcome] = react.useState(null);
|
|
3030
|
+
const redeem = react.useCallback(
|
|
3031
|
+
async (namespaceId, invitation, options = {}) => {
|
|
3032
|
+
if (!mero) return null;
|
|
3033
|
+
if (mountedRef.current) {
|
|
3034
|
+
setLoading(true);
|
|
3035
|
+
setOutcome(null);
|
|
3036
|
+
}
|
|
3037
|
+
try {
|
|
3038
|
+
const result = await mero.admin.redeemInvitation(namespaceId, invitation, options);
|
|
3039
|
+
if (mountedRef.current) setOutcome(result);
|
|
3040
|
+
return result;
|
|
3041
|
+
} finally {
|
|
3042
|
+
if (mountedRef.current) setLoading(false);
|
|
3043
|
+
}
|
|
3044
|
+
},
|
|
3045
|
+
[mero, mountedRef]
|
|
3046
|
+
);
|
|
3047
|
+
return { redeem, outcome, loading };
|
|
3048
|
+
}
|
|
3049
|
+
function useCreateGroupInNamespace() {
|
|
3050
|
+
const { mero, isDelegated } = useMero();
|
|
2116
3051
|
const { loading, error, run } = useAsyncMutation();
|
|
2117
3052
|
const createGroupInNamespace = react.useCallback(
|
|
2118
3053
|
async (namespaceId, request) => {
|
|
3054
|
+
if (isDelegated) {
|
|
3055
|
+
const session = readDelegatedSession();
|
|
3056
|
+
if (!session) return null;
|
|
3057
|
+
return run(async () => {
|
|
3058
|
+
const { groupId } = await governRoot(
|
|
3059
|
+
session,
|
|
3060
|
+
namespaceId,
|
|
3061
|
+
// The id is derived from a fresh salt (core#4244); a node refuses any other.
|
|
3062
|
+
(await meroJs.subgroupCreation({
|
|
3063
|
+
parentId: namespaceId,
|
|
3064
|
+
restricted: request?.visibility !== "open",
|
|
3065
|
+
admin: session.account
|
|
3066
|
+
})).op
|
|
3067
|
+
);
|
|
3068
|
+
rememberGroupNamespace(session.account, groupId, namespaceId);
|
|
3069
|
+
return { groupId };
|
|
3070
|
+
});
|
|
3071
|
+
}
|
|
2119
3072
|
if (!mero) return null;
|
|
2120
3073
|
return run(() => mero.admin.createGroupInNamespace(namespaceId, request));
|
|
2121
3074
|
},
|
|
2122
|
-
[mero, run]
|
|
3075
|
+
[mero, run, isDelegated]
|
|
2123
3076
|
);
|
|
2124
3077
|
return { createGroupInNamespace, loading, error };
|
|
2125
3078
|
}
|
|
@@ -2133,38 +3086,55 @@ function useNamespaceGroups(namespaceId) {
|
|
|
2133
3086
|
return { groups: data, loading, error, refetch };
|
|
2134
3087
|
}
|
|
2135
3088
|
function useUpdateMemberRole() {
|
|
2136
|
-
const { mero } = useMero();
|
|
3089
|
+
const { mero, isDelegated } = useMero();
|
|
2137
3090
|
const { loading, error, run } = useAsyncMutation();
|
|
2138
3091
|
const updateMemberRole = react.useCallback(
|
|
2139
3092
|
async (groupId, identity, request) => {
|
|
3093
|
+
if (isDelegated) {
|
|
3094
|
+
const session = readDelegatedSession();
|
|
3095
|
+
if (!session) return null;
|
|
3096
|
+
return run(() => governGroup(session, groupId, meroJs.memberRoleSetOp(identity, request.role)));
|
|
3097
|
+
}
|
|
2140
3098
|
if (!mero) return null;
|
|
2141
3099
|
return run(() => mero.admin.updateMemberRole(groupId, identity, request));
|
|
2142
3100
|
},
|
|
2143
|
-
[mero, run]
|
|
3101
|
+
[mero, run, isDelegated]
|
|
2144
3102
|
);
|
|
2145
3103
|
return { updateMemberRole, loading, error };
|
|
2146
3104
|
}
|
|
2147
3105
|
function useSetDefaultCapabilities() {
|
|
2148
|
-
const { mero } = useMero();
|
|
3106
|
+
const { mero, isDelegated } = useMero();
|
|
2149
3107
|
const { loading, error, run } = useAsyncMutation();
|
|
2150
3108
|
const setDefaultCapabilities = react.useCallback(
|
|
2151
3109
|
async (groupId, request) => {
|
|
3110
|
+
if (isDelegated) {
|
|
3111
|
+
const session = readDelegatedSession();
|
|
3112
|
+
if (!session) return null;
|
|
3113
|
+
return run(() => governGroup(session, groupId, meroJs.defaultCapabilitiesSetOp(request.defaultCapabilities)));
|
|
3114
|
+
}
|
|
2152
3115
|
if (!mero) return null;
|
|
2153
3116
|
return run(() => mero.admin.setDefaultCapabilities(groupId, request));
|
|
2154
3117
|
},
|
|
2155
|
-
[mero, run]
|
|
3118
|
+
[mero, run, isDelegated]
|
|
2156
3119
|
);
|
|
2157
3120
|
return { setDefaultCapabilities, loading, error };
|
|
2158
3121
|
}
|
|
2159
3122
|
function useSetSubgroupVisibility() {
|
|
2160
|
-
const { mero } = useMero();
|
|
3123
|
+
const { mero, isDelegated } = useMero();
|
|
2161
3124
|
const { loading, error, run } = useAsyncMutation();
|
|
2162
3125
|
const setSubgroupVisibility = react.useCallback(
|
|
2163
3126
|
async (groupId, request) => {
|
|
3127
|
+
if (isDelegated) {
|
|
3128
|
+
const session = readDelegatedSession();
|
|
3129
|
+
if (!session) return null;
|
|
3130
|
+
return run(
|
|
3131
|
+
() => governGroup(session, groupId, meroJs.subgroupVisibilitySetOp(request.subgroupVisibility === "open" ? "open" : "restricted"))
|
|
3132
|
+
);
|
|
3133
|
+
}
|
|
2164
3134
|
if (!mero) return null;
|
|
2165
3135
|
return run(() => mero.admin.setSubgroupVisibility(groupId, request));
|
|
2166
3136
|
},
|
|
2167
|
-
[mero, run]
|
|
3137
|
+
[mero, run, isDelegated]
|
|
2168
3138
|
);
|
|
2169
3139
|
return { setSubgroupVisibility, loading, error };
|
|
2170
3140
|
}
|
|
@@ -2199,38 +3169,53 @@ function useSetTeeAdmissionPolicy() {
|
|
|
2199
3169
|
return { setTeeAdmissionPolicy, loading, error };
|
|
2200
3170
|
}
|
|
2201
3171
|
function useSetGroupMetadata() {
|
|
2202
|
-
const { mero } = useMero();
|
|
3172
|
+
const { mero, isDelegated } = useMero();
|
|
2203
3173
|
const { loading, error, run } = useAsyncMutation();
|
|
2204
3174
|
const setGroupMetadata = react.useCallback(
|
|
2205
3175
|
async (groupId, request) => {
|
|
3176
|
+
if (isDelegated) {
|
|
3177
|
+
const session = readDelegatedSession();
|
|
3178
|
+
if (!session) return null;
|
|
3179
|
+
return run(() => governGroup(session, groupId, meroJs.groupMetadataSetOp(request)));
|
|
3180
|
+
}
|
|
2206
3181
|
if (!mero) return null;
|
|
2207
3182
|
return run(() => mero.admin.setGroupMetadata(groupId, request));
|
|
2208
3183
|
},
|
|
2209
|
-
[mero, run]
|
|
3184
|
+
[mero, run, isDelegated]
|
|
2210
3185
|
);
|
|
2211
3186
|
return { setGroupMetadata, loading, error };
|
|
2212
3187
|
}
|
|
2213
3188
|
function useSetMemberMetadata() {
|
|
2214
|
-
const { mero } = useMero();
|
|
3189
|
+
const { mero, isDelegated } = useMero();
|
|
2215
3190
|
const { loading, error, run } = useAsyncMutation();
|
|
2216
3191
|
const setMemberMetadata = react.useCallback(
|
|
2217
3192
|
async (groupId, identity, request) => {
|
|
3193
|
+
if (isDelegated) {
|
|
3194
|
+
const session = readDelegatedSession();
|
|
3195
|
+
if (!session) return null;
|
|
3196
|
+
return run(() => governGroup(session, groupId, meroJs.memberMetadataSetOp(identity, request)));
|
|
3197
|
+
}
|
|
2218
3198
|
if (!mero) return null;
|
|
2219
3199
|
return run(() => mero.admin.setMemberMetadata(groupId, identity, request));
|
|
2220
3200
|
},
|
|
2221
|
-
[mero, run]
|
|
3201
|
+
[mero, run, isDelegated]
|
|
2222
3202
|
);
|
|
2223
3203
|
return { setMemberMetadata, loading, error };
|
|
2224
3204
|
}
|
|
2225
3205
|
function useSetContextMetadata() {
|
|
2226
|
-
const { mero } = useMero();
|
|
3206
|
+
const { mero, isDelegated } = useMero();
|
|
2227
3207
|
const { loading, error, run } = useAsyncMutation();
|
|
2228
3208
|
const setContextMetadata = react.useCallback(
|
|
2229
3209
|
async (groupId, contextId, request) => {
|
|
3210
|
+
if (isDelegated) {
|
|
3211
|
+
const session = readDelegatedSession();
|
|
3212
|
+
if (!session) return null;
|
|
3213
|
+
return run(() => governGroup(session, groupId, meroJs.contextMetadataSetOp(contextId, request)));
|
|
3214
|
+
}
|
|
2230
3215
|
if (!mero) return null;
|
|
2231
3216
|
return run(() => mero.admin.setContextMetadata(groupId, contextId, request));
|
|
2232
3217
|
},
|
|
2233
|
-
[mero, run]
|
|
3218
|
+
[mero, run, isDelegated]
|
|
2234
3219
|
);
|
|
2235
3220
|
return { setContextMetadata, loading, error };
|
|
2236
3221
|
}
|
|
@@ -2389,14 +3374,22 @@ function useRetryGroupUpgrade() {
|
|
|
2389
3374
|
return { retryGroupUpgrade, loading, error };
|
|
2390
3375
|
}
|
|
2391
3376
|
function useReparentGroup() {
|
|
2392
|
-
const { mero } = useMero();
|
|
3377
|
+
const { mero, isDelegated } = useMero();
|
|
2393
3378
|
const { loading, error, run } = useAsyncMutation();
|
|
2394
3379
|
const reparentGroup = react.useCallback(
|
|
2395
3380
|
async (childGroupId, request) => {
|
|
3381
|
+
if (isDelegated) {
|
|
3382
|
+
const session = readDelegatedSession();
|
|
3383
|
+
if (!session) return null;
|
|
3384
|
+
return run(async () => {
|
|
3385
|
+
await governRoot(session, childGroupId, meroJs.groupReparentedOp(childGroupId, request.newParentId));
|
|
3386
|
+
return { reparented: true };
|
|
3387
|
+
});
|
|
3388
|
+
}
|
|
2396
3389
|
if (!mero) return null;
|
|
2397
3390
|
return run(() => mero.admin.reparentGroup(childGroupId, request));
|
|
2398
3391
|
},
|
|
2399
|
-
[mero, run]
|
|
3392
|
+
[mero, run, isDelegated]
|
|
2400
3393
|
);
|
|
2401
3394
|
return { reparentGroup, loading, error };
|
|
2402
3395
|
}
|
|
@@ -2410,14 +3403,19 @@ function useSubgroups(groupId) {
|
|
|
2410
3403
|
return { subgroups: data, loading, error, refetch };
|
|
2411
3404
|
}
|
|
2412
3405
|
function useDetachContextFromGroup() {
|
|
2413
|
-
const { mero } = useMero();
|
|
3406
|
+
const { mero, isDelegated } = useMero();
|
|
2414
3407
|
const { loading, error, run } = useAsyncMutation();
|
|
2415
3408
|
const detachContextFromGroup = react.useCallback(
|
|
2416
3409
|
async (groupId, contextId) => {
|
|
3410
|
+
if (isDelegated) {
|
|
3411
|
+
const session = readDelegatedSession();
|
|
3412
|
+
if (!session) return null;
|
|
3413
|
+
return run(() => governGroup(session, groupId, meroJs.contextDetachedOp(contextId)));
|
|
3414
|
+
}
|
|
2417
3415
|
if (!mero) return null;
|
|
2418
3416
|
return run(() => mero.admin.detachContextFromGroup(groupId, contextId));
|
|
2419
3417
|
},
|
|
2420
|
-
[mero, run]
|
|
3418
|
+
[mero, run, isDelegated]
|
|
2421
3419
|
);
|
|
2422
3420
|
return { detachContextFromGroup, loading, error };
|
|
2423
3421
|
}
|
|
@@ -2929,6 +3927,359 @@ function MigrationAdminPanel({ namespaceId, pollIntervalMs, className }) {
|
|
|
2929
3927
|
] })
|
|
2930
3928
|
] });
|
|
2931
3929
|
}
|
|
3930
|
+
function normaliseAccount(account) {
|
|
3931
|
+
if (!account) return null;
|
|
3932
|
+
const trimmed = account.trim().toLowerCase();
|
|
3933
|
+
const bare = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
|
|
3934
|
+
return bare.length > 0 ? bare : null;
|
|
3935
|
+
}
|
|
3936
|
+
function isInvited(node, invited) {
|
|
3937
|
+
if (invited.size === 0) return true;
|
|
3938
|
+
const account = normaliseAccount(node.account);
|
|
3939
|
+
return account !== null && invited.has(account);
|
|
3940
|
+
}
|
|
3941
|
+
async function resolveRelayFromInvitation(input) {
|
|
3942
|
+
const cloud = input.cloud ?? new meroJs.CloudClient({
|
|
3943
|
+
cloudBaseUrl: input.cloudBaseUrl,
|
|
3944
|
+
routingCredential: { credential: input.credential, deviceSecret: input.deviceSecret }
|
|
3945
|
+
});
|
|
3946
|
+
let nodes;
|
|
3947
|
+
let servable;
|
|
3948
|
+
try {
|
|
3949
|
+
const routing = await cloud.getNamespaceRouting(input.namespaceId);
|
|
3950
|
+
nodes = routing.nodes;
|
|
3951
|
+
servable = routing.servable;
|
|
3952
|
+
} catch (e) {
|
|
3953
|
+
return {
|
|
3954
|
+
ok: false,
|
|
3955
|
+
step: "admitters-lookup",
|
|
3956
|
+
reason: `The cloud could not be asked which nodes serve namespace ${input.namespaceId}: ${e instanceof Error ? e.message : String(e)}. Nothing is known about the invitation yet \u2014 this is the lookup failing, not the invitation.`
|
|
3957
|
+
};
|
|
3958
|
+
}
|
|
3959
|
+
if (nodes.length === 0) {
|
|
3960
|
+
return {
|
|
3961
|
+
ok: false,
|
|
3962
|
+
step: "no-nodes",
|
|
3963
|
+
reason: "The cloud lists no nodes serving this namespace, so there is no hosted node to be admitted through. The namespace has no fleet assignment \u2014 whoever invited you is running their own node, and admission has to go through a node the cloud routes to."
|
|
3964
|
+
};
|
|
3965
|
+
}
|
|
3966
|
+
const invited = new Set(
|
|
3967
|
+
(input.admitters ?? []).map(normaliseAccount).filter((a) => a !== null)
|
|
3968
|
+
);
|
|
3969
|
+
const named = nodes.filter((n) => isInvited(n, invited));
|
|
3970
|
+
if (named.length === 0) {
|
|
3971
|
+
return {
|
|
3972
|
+
ok: false,
|
|
3973
|
+
step: "not-invited",
|
|
3974
|
+
reason: `${nodes.length} node${nodes.length === 1 ? "" : "s"} serve this namespace, but your invitation names none of them. The signed admitter list is a snapshot from when the invitation was minted, so a node assigned since is healthy and will still refuse the claim. Ask for a fresh invitation.`
|
|
3975
|
+
};
|
|
3976
|
+
}
|
|
3977
|
+
const usable = named.filter((n) => n.canAdmit);
|
|
3978
|
+
const candidates = usable.length > 0 ? usable : named;
|
|
3979
|
+
const advisory = usable.length === 0 || !servable;
|
|
3980
|
+
const addressable = candidates.filter(
|
|
3981
|
+
(n) => typeof n.relayUrl === "string" && n.relayUrl.length > 0
|
|
3982
|
+
);
|
|
3983
|
+
if (addressable.length === 0) {
|
|
3984
|
+
return {
|
|
3985
|
+
ok: false,
|
|
3986
|
+
step: "no-relay-url",
|
|
3987
|
+
reason: "A node your invitation names can admit you, but the cloud knows no address for it yet, so there would be nothing to connect through afterwards. Try again shortly."
|
|
3988
|
+
};
|
|
3989
|
+
}
|
|
3990
|
+
const chosen = addressable.find((n) => n.canExecute) ?? addressable.find((n) => n.fresh) ?? addressable[0];
|
|
3991
|
+
return {
|
|
3992
|
+
ok: true,
|
|
3993
|
+
relayUrl: chosen.relayUrl,
|
|
3994
|
+
// The cloud's ready-made URL when it gave one, so the path is never rebuilt
|
|
3995
|
+
// from a guess; the fallback is the documented route on the same origin.
|
|
3996
|
+
admitUrl: chosen.admitUrl ?? `${chosen.relayUrl.replace(/\/+$/, "")}/admin-api/namespaces/${input.namespaceId}/admit`,
|
|
3997
|
+
admitterAccount: chosen.account,
|
|
3998
|
+
peerId: chosen.peerId,
|
|
3999
|
+
writable: chosen.canExecute,
|
|
4000
|
+
// Stale when the node's own heartbeat lapsed OR when the cloud's summary
|
|
4001
|
+
// disagrees with trying it at all. Both mean the same thing to a caller:
|
|
4002
|
+
// this was attempted on advisory data, so if the admit fails that is why.
|
|
4003
|
+
stale: !chosen.fresh || advisory
|
|
4004
|
+
};
|
|
4005
|
+
}
|
|
4006
|
+
function explainAdmitFailure(status, body) {
|
|
4007
|
+
const detail = body ? `: ${body}` : "";
|
|
4008
|
+
switch (status) {
|
|
4009
|
+
case 400:
|
|
4010
|
+
return `The node refused the join as malformed (400)${detail}. The signature covers the invitation exactly as sent, so an edited or re-serialised invitation fails here \u2014 as does a namespace id that is not the invitation's own group.`;
|
|
4011
|
+
case 403:
|
|
4012
|
+
return `The node refused to carry this join (403)${detail}. Either it is not in the invitation's signed admitters list \u2014 being live and listed by the cloud is not the same thing \u2014 or the invitation itself was rejected as expired or not the inviter\u2019s to issue.`;
|
|
4013
|
+
case 409:
|
|
4014
|
+
return `That node holds no device of its own, so it cannot endorse anyone (409)${detail}. Another admitter from the same invitation would work.`;
|
|
4015
|
+
default:
|
|
4016
|
+
return `The join was not published (HTTP ${status})${detail}.`;
|
|
4017
|
+
}
|
|
4018
|
+
}
|
|
4019
|
+
function joinNonce(account) {
|
|
4020
|
+
const source = meroJs.createLocalStorageNonceSource(`calimero.delegated.joinnonce.${account}`);
|
|
4021
|
+
return () => source.next();
|
|
4022
|
+
}
|
|
4023
|
+
function origin(url) {
|
|
4024
|
+
return url.replace(/\/+$/, "");
|
|
4025
|
+
}
|
|
4026
|
+
async function joinWithNode(input) {
|
|
4027
|
+
const { account, credential, deviceSecret } = input.credential;
|
|
4028
|
+
let signedOp;
|
|
4029
|
+
try {
|
|
4030
|
+
signedOp = await meroJs.signMemberJoinOp({
|
|
4031
|
+
namespaceId: input.namespaceId,
|
|
4032
|
+
member: account,
|
|
4033
|
+
invitation: input.invitation,
|
|
4034
|
+
credential,
|
|
4035
|
+
deviceSecret,
|
|
4036
|
+
nonce: await (input.deps?.nonce ?? joinNonce(account))()
|
|
4037
|
+
});
|
|
4038
|
+
} catch (e) {
|
|
4039
|
+
return {
|
|
4040
|
+
ok: false,
|
|
4041
|
+
step: "sign",
|
|
4042
|
+
reason: `The join op could not be signed, so nothing was sent: ${e instanceof Error ? e.message : String(e)}`
|
|
4043
|
+
};
|
|
4044
|
+
}
|
|
4045
|
+
const body = { invitation: input.invitation, signedOp };
|
|
4046
|
+
const url = input.admitUrl ?? `${origin(input.nodeUrl)}/admin-api/namespaces/${input.namespaceId}/admit`;
|
|
4047
|
+
const doFetch = input.deps?.fetch ?? fetch;
|
|
4048
|
+
let response;
|
|
4049
|
+
try {
|
|
4050
|
+
response = await doFetch(url, {
|
|
4051
|
+
method: "POST",
|
|
4052
|
+
// No Authorization header and no request proof, deliberately: the route is
|
|
4053
|
+
// unauthenticated because the joiner's signature is the authorization.
|
|
4054
|
+
headers: { "Content-Type": "application/json", Accept: "application/json" },
|
|
4055
|
+
body: JSON.stringify(body)
|
|
4056
|
+
});
|
|
4057
|
+
} catch (e) {
|
|
4058
|
+
return {
|
|
4059
|
+
ok: false,
|
|
4060
|
+
step: "admit",
|
|
4061
|
+
reason: `The admitter at ${input.nodeUrl} could not be reached: ${e instanceof Error ? e.message : String(e)}. The invitation is untouched \u2014 this is the node being unreachable, not a refusal.`
|
|
4062
|
+
};
|
|
4063
|
+
}
|
|
4064
|
+
const text = await response.text();
|
|
4065
|
+
if (!response.ok) {
|
|
4066
|
+
return {
|
|
4067
|
+
ok: false,
|
|
4068
|
+
step: "admit",
|
|
4069
|
+
status: response.status,
|
|
4070
|
+
reason: explainAdmitFailure(response.status, text)
|
|
4071
|
+
};
|
|
4072
|
+
}
|
|
4073
|
+
let published = false;
|
|
4074
|
+
try {
|
|
4075
|
+
const parsed = text ? JSON.parse(text) : {};
|
|
4076
|
+
published = parsed.data?.published === true;
|
|
4077
|
+
} catch {
|
|
4078
|
+
published = false;
|
|
4079
|
+
}
|
|
4080
|
+
return {
|
|
4081
|
+
ok: true,
|
|
4082
|
+
published,
|
|
4083
|
+
session: { relayUrl: origin(input.nodeUrl), account, credential, deviceSecret }
|
|
4084
|
+
};
|
|
4085
|
+
}
|
|
4086
|
+
|
|
4087
|
+
// src/delegated/bootstrap-from-invitation.ts
|
|
4088
|
+
async function bootstrapFromInvitation(input) {
|
|
4089
|
+
const resolve = input.deps?.resolve ?? resolveRelayFromInvitation;
|
|
4090
|
+
const join = input.deps?.join ?? joinWithNode;
|
|
4091
|
+
let relay = null;
|
|
4092
|
+
let nodeUrl = input.nodeUrl;
|
|
4093
|
+
let admitUrl;
|
|
4094
|
+
if (!nodeUrl) {
|
|
4095
|
+
const resolved = await resolve({
|
|
4096
|
+
namespaceId: input.namespaceId,
|
|
4097
|
+
// The signed list, read off the invitation itself rather than passed
|
|
4098
|
+
// separately: two sources for one fact is how an intersection ends up
|
|
4099
|
+
// being performed against the wrong list.
|
|
4100
|
+
admitters: input.invitation.invitation.admitters,
|
|
4101
|
+
credential: input.credential.credential,
|
|
4102
|
+
deviceSecret: input.credential.deviceSecret,
|
|
4103
|
+
cloudBaseUrl: input.cloudBaseUrl
|
|
4104
|
+
});
|
|
4105
|
+
if (!resolved.ok) return resolved;
|
|
4106
|
+
relay = resolved;
|
|
4107
|
+
nodeUrl = resolved.relayUrl;
|
|
4108
|
+
admitUrl = resolved.admitUrl;
|
|
4109
|
+
}
|
|
4110
|
+
const joined = await join({
|
|
4111
|
+
nodeUrl,
|
|
4112
|
+
admitUrl,
|
|
4113
|
+
namespaceId: input.namespaceId,
|
|
4114
|
+
invitation: input.invitation,
|
|
4115
|
+
credential: input.credential,
|
|
4116
|
+
deps: { fetch: input.deps?.fetch, nonce: input.deps?.nonce }
|
|
4117
|
+
});
|
|
4118
|
+
if (!joined.ok) return joined;
|
|
4119
|
+
return { ok: true, published: joined.published, relay, session: joined.session };
|
|
4120
|
+
}
|
|
4121
|
+
function useDelegatedBootstrap(options = {}) {
|
|
4122
|
+
const { connectWithAccount } = useMero();
|
|
4123
|
+
const [running, setRunning] = react.useState(false);
|
|
4124
|
+
const [result, setResult] = react.useState(null);
|
|
4125
|
+
const credential = readDelegatedCredential();
|
|
4126
|
+
const relayUrl = readDelegatedSession()?.relayUrl ?? null;
|
|
4127
|
+
const { cloudBaseUrl } = options;
|
|
4128
|
+
const bootstrap = react.useCallback(
|
|
4129
|
+
async (input) => {
|
|
4130
|
+
const held = readDelegatedCredential();
|
|
4131
|
+
if (!held) {
|
|
4132
|
+
const failure = {
|
|
4133
|
+
ok: false,
|
|
4134
|
+
step: "no-credential",
|
|
4135
|
+
reason: "This tab holds no enrolled account, so there is no identity to admit. Enrol with your account first \u2014 the invitation is then what gives it its first membership."
|
|
4136
|
+
};
|
|
4137
|
+
setResult(failure);
|
|
4138
|
+
return failure;
|
|
4139
|
+
}
|
|
4140
|
+
setRunning(true);
|
|
4141
|
+
try {
|
|
4142
|
+
const outcome = await bootstrapFromInvitation({
|
|
4143
|
+
namespaceId: input.namespaceId,
|
|
4144
|
+
invitation: input.invitation,
|
|
4145
|
+
credential: held,
|
|
4146
|
+
nodeUrl: input.nodeUrl,
|
|
4147
|
+
cloudBaseUrl
|
|
4148
|
+
});
|
|
4149
|
+
setResult(outcome);
|
|
4150
|
+
if (outcome.ok) {
|
|
4151
|
+
if (outcome.session.relayUrl) {
|
|
4152
|
+
rememberRelay(held.account, outcome.session.relayUrl, {
|
|
4153
|
+
namespaceId: input.namespaceId,
|
|
4154
|
+
contextId: input.contextId
|
|
4155
|
+
});
|
|
4156
|
+
}
|
|
4157
|
+
connectWithAccount(outcome.session);
|
|
4158
|
+
}
|
|
4159
|
+
return outcome;
|
|
4160
|
+
} finally {
|
|
4161
|
+
setRunning(false);
|
|
4162
|
+
}
|
|
4163
|
+
},
|
|
4164
|
+
[cloudBaseUrl, connectWithAccount]
|
|
4165
|
+
);
|
|
4166
|
+
return {
|
|
4167
|
+
credential,
|
|
4168
|
+
needsBootstrap: credential !== null && relayUrl === null,
|
|
4169
|
+
running,
|
|
4170
|
+
result,
|
|
4171
|
+
bootstrap
|
|
4172
|
+
};
|
|
4173
|
+
}
|
|
4174
|
+
function statusOf(err) {
|
|
4175
|
+
if (!err || typeof err !== "object") return void 0;
|
|
4176
|
+
const e = err;
|
|
4177
|
+
for (const c of [e.status, e.response?.status, e.statusCode]) {
|
|
4178
|
+
if (typeof c === "number" && Number.isFinite(c)) return c;
|
|
4179
|
+
}
|
|
4180
|
+
return void 0;
|
|
4181
|
+
}
|
|
4182
|
+
var STEP_LABEL = {
|
|
4183
|
+
"no-credential": "No enrolled account",
|
|
4184
|
+
"admitters-lookup": "Admitters lookup failed",
|
|
4185
|
+
"no-nodes": "No hosted node serves this namespace",
|
|
4186
|
+
"not-invited": "This invitation names none of the serving nodes",
|
|
4187
|
+
"invited-unreachable": "The invited admitter cannot take a join right now",
|
|
4188
|
+
"no-relay-url": "The invited admitter has no address yet",
|
|
4189
|
+
sign: "The join could not be signed",
|
|
4190
|
+
admit: "The admitter refused the join"
|
|
4191
|
+
};
|
|
4192
|
+
function accountJoinIsFinal(failure) {
|
|
4193
|
+
if (failure.step === "admit") return failure.status === 400 || failure.status === 403;
|
|
4194
|
+
return failure.step === "not-invited" || failure.step === "sign";
|
|
4195
|
+
}
|
|
4196
|
+
function isFinalInvitationError(message) {
|
|
4197
|
+
if (!message) return false;
|
|
4198
|
+
const m = message.toLowerCase();
|
|
4199
|
+
return [
|
|
4200
|
+
"invitation expired",
|
|
4201
|
+
"expired invitation",
|
|
4202
|
+
"invalid invitation",
|
|
4203
|
+
"invitation is invalid",
|
|
4204
|
+
"malformed invitation",
|
|
4205
|
+
"malformed payload",
|
|
4206
|
+
"invalid signature",
|
|
4207
|
+
"signature verification failed",
|
|
4208
|
+
"not admin",
|
|
4209
|
+
"revoked",
|
|
4210
|
+
"already a member"
|
|
4211
|
+
].some((t) => m.includes(t));
|
|
4212
|
+
}
|
|
4213
|
+
function useJoinInvitation() {
|
|
4214
|
+
const { mero, isDelegated } = useMero();
|
|
4215
|
+
const { credential, bootstrap } = useDelegatedBootstrap();
|
|
4216
|
+
const [joining, setJoining] = react.useState(false);
|
|
4217
|
+
const joinInvitation = react.useCallback(
|
|
4218
|
+
async (input) => {
|
|
4219
|
+
setJoining(true);
|
|
4220
|
+
try {
|
|
4221
|
+
const asAccount = isDelegated || credential !== null && mero === null;
|
|
4222
|
+
if (asAccount) {
|
|
4223
|
+
const outcome = await bootstrap({
|
|
4224
|
+
namespaceId: input.namespaceId,
|
|
4225
|
+
invitation: input.invitation,
|
|
4226
|
+
contextId: input.contextId
|
|
4227
|
+
});
|
|
4228
|
+
if (outcome.ok) return { ok: true };
|
|
4229
|
+
return {
|
|
4230
|
+
ok: false,
|
|
4231
|
+
step: outcome.step,
|
|
4232
|
+
reason: `${STEP_LABEL[outcome.step]}. ${outcome.reason}`,
|
|
4233
|
+
final: accountJoinIsFinal(outcome),
|
|
4234
|
+
...outcome.status !== void 0 ? { status: outcome.status } : {}
|
|
4235
|
+
};
|
|
4236
|
+
}
|
|
4237
|
+
if (!mero) {
|
|
4238
|
+
return { ok: false, step: "node-join", reason: "Not connected to a node.", final: false };
|
|
4239
|
+
}
|
|
4240
|
+
await mero.admin.joinNamespace(input.namespaceId, { invitation: input.invitation });
|
|
4241
|
+
await mero.admin.joinContext(input.contextId);
|
|
4242
|
+
return { ok: true };
|
|
4243
|
+
} catch (e) {
|
|
4244
|
+
const reason = e instanceof Error ? e.message : String(e);
|
|
4245
|
+
const status = statusOf(e);
|
|
4246
|
+
return {
|
|
4247
|
+
ok: false,
|
|
4248
|
+
step: "node-join",
|
|
4249
|
+
reason,
|
|
4250
|
+
final: isFinalInvitationError(reason),
|
|
4251
|
+
...status !== void 0 ? { status } : {}
|
|
4252
|
+
};
|
|
4253
|
+
} finally {
|
|
4254
|
+
setJoining(false);
|
|
4255
|
+
}
|
|
4256
|
+
},
|
|
4257
|
+
[mero, isDelegated, credential, bootstrap]
|
|
4258
|
+
);
|
|
4259
|
+
const memberships = react.useCallback(async () => {
|
|
4260
|
+
const asAccount = isDelegated || credential !== null && mero === null;
|
|
4261
|
+
const ids = (list) => list.map((n) => n.namespaceId ?? n.groupId ?? n.id ?? "").filter(Boolean);
|
|
4262
|
+
if (asAccount) {
|
|
4263
|
+
const session = readDelegatedSession();
|
|
4264
|
+
return session ? ids(await listDelegatedNamespaces(session)) : [];
|
|
4265
|
+
}
|
|
4266
|
+
if (!mero) return [];
|
|
4267
|
+
return ids(await mero.admin.listNamespaces());
|
|
4268
|
+
}, [mero, isDelegated, credential]);
|
|
4269
|
+
const invitationRedeemer = react.useCallback(
|
|
4270
|
+
(input) => ({
|
|
4271
|
+
join: async () => {
|
|
4272
|
+
const outcome = await joinInvitation(input);
|
|
4273
|
+
if (!outcome.ok) {
|
|
4274
|
+
throw Object.assign(new Error(outcome.reason), outcome.status !== void 0 ? { status: outcome.status } : {});
|
|
4275
|
+
}
|
|
4276
|
+
},
|
|
4277
|
+
memberships
|
|
4278
|
+
}),
|
|
4279
|
+
[joinInvitation, memberships]
|
|
4280
|
+
);
|
|
4281
|
+
return { joinInvitation, joining, memberships, invitationRedeemer };
|
|
4282
|
+
}
|
|
2932
4283
|
|
|
2933
4284
|
Object.defineProperty(exports, "CAPABILITIES", {
|
|
2934
4285
|
enumerable: true,
|
|
@@ -2969,6 +4320,7 @@ Object.defineProperty(exports, "withoutCap", {
|
|
|
2969
4320
|
exports.AppMode = AppMode;
|
|
2970
4321
|
exports.CalimeroLogo = CalimeroLogo;
|
|
2971
4322
|
exports.ConnectButton = ConnectButton;
|
|
4323
|
+
exports.ConnectButtonAccount = ConnectButtonAccount;
|
|
2972
4324
|
exports.ConnectionType = ConnectionType;
|
|
2973
4325
|
exports.DEFAULT_MIGRATION_POLL_INTERVAL_MS = DEFAULT_MIGRATION_POLL_INTERVAL_MS;
|
|
2974
4326
|
exports.LoginModal = LoginModal;
|
|
@@ -2977,12 +4329,15 @@ exports.MeroContext = MeroContext;
|
|
|
2977
4329
|
exports.MeroProvider = MeroProvider;
|
|
2978
4330
|
exports.MigrationAdminPanel = MigrationAdminPanel;
|
|
2979
4331
|
exports.MigrationPendingBanner = MigrationPendingBanner;
|
|
4332
|
+
exports.bootstrapFromInvitation = bootstrapFromInvitation;
|
|
2980
4333
|
exports.clearAllStorage = clearAllStorage;
|
|
2981
4334
|
exports.clearApplicationId = clearApplicationId;
|
|
2982
4335
|
exports.clearContextId = clearContextId;
|
|
2983
4336
|
exports.clearContextIdentity = clearContextIdentity;
|
|
4337
|
+
exports.clearDelegatedCredential = clearDelegatedCredential;
|
|
2984
4338
|
exports.clearNodeUrl = clearNodeUrl;
|
|
2985
4339
|
exports.clearTokenNodeUrl = clearTokenNodeUrl;
|
|
4340
|
+
exports.createDelegatedContext = createDelegatedContext;
|
|
2986
4341
|
exports.cssVar = cssVar;
|
|
2987
4342
|
exports.defaultMeroTheme = defaultMeroTheme;
|
|
2988
4343
|
exports.getApplicationId = getApplicationId;
|
|
@@ -2990,8 +4345,20 @@ exports.getContextId = getContextId;
|
|
|
2990
4345
|
exports.getContextIdentity = getContextIdentity;
|
|
2991
4346
|
exports.getNodeUrl = getNodeUrl;
|
|
2992
4347
|
exports.getTokenNodeUrl = getTokenNodeUrl;
|
|
4348
|
+
exports.isFinalInvitationError = isFinalInvitationError;
|
|
4349
|
+
exports.joinWithNode = joinWithNode;
|
|
4350
|
+
exports.listDelegatedContexts = listDelegatedContexts;
|
|
2993
4351
|
exports.localStorageTokenStorage = localStorageTokenStorage;
|
|
4352
|
+
exports.normaliseAccount = normaliseAccount;
|
|
4353
|
+
exports.pinRelayNodeKey = pinRelayNodeKey;
|
|
4354
|
+
exports.readDelegatedCredential = readDelegatedCredential;
|
|
4355
|
+
exports.readPinnedRelayNodeKey = readPinnedRelayNodeKey;
|
|
4356
|
+
exports.readRelayMap = readRelayMap;
|
|
4357
|
+
exports.relayForContext = relayForContext;
|
|
4358
|
+
exports.rememberRelay = rememberRelay;
|
|
2994
4359
|
exports.resolveMeroTheme = resolveMeroTheme;
|
|
4360
|
+
exports.resolveRelayFromInvitation = resolveRelayFromInvitation;
|
|
4361
|
+
exports.saveDelegatedCredential = saveDelegatedCredential;
|
|
2995
4362
|
exports.setApplicationId = setApplicationId;
|
|
2996
4363
|
exports.setContextId = setContextId;
|
|
2997
4364
|
exports.setContextIdentity = setContextIdentity;
|
|
@@ -3010,7 +4377,9 @@ exports.useCreateContext = useCreateContext;
|
|
|
3010
4377
|
exports.useCreateGroupInNamespace = useCreateGroupInNamespace;
|
|
3011
4378
|
exports.useCreateNamespace = useCreateNamespace;
|
|
3012
4379
|
exports.useCreateNamespaceInvitation = useCreateNamespaceInvitation;
|
|
4380
|
+
exports.useCreatePrivateContext = useCreatePrivateContext;
|
|
3013
4381
|
exports.useDefaultCapabilities = useDefaultCapabilities;
|
|
4382
|
+
exports.useDelegatedBootstrap = useDelegatedBootstrap;
|
|
3014
4383
|
exports.useDeleteContext = useDeleteContext;
|
|
3015
4384
|
exports.useDeleteGroup = useDeleteGroup;
|
|
3016
4385
|
exports.useDeleteNamespace = useDeleteNamespace;
|
|
@@ -3028,6 +4397,7 @@ exports.useGroupUpgradeStatus = useGroupUpgradeStatus;
|
|
|
3028
4397
|
exports.useInstallFromRegistry = useInstallFromRegistry;
|
|
3029
4398
|
exports.useJoinContext = useJoinContext;
|
|
3030
4399
|
exports.useJoinGroup = useJoinGroup;
|
|
4400
|
+
exports.useJoinInvitation = useJoinInvitation;
|
|
3031
4401
|
exports.useJoinNamespace = useJoinNamespace;
|
|
3032
4402
|
exports.useJoinSubgroupInheritance = useJoinSubgroupInheritance;
|
|
3033
4403
|
exports.useLatestVersion = useLatestVersion;
|
|
@@ -3042,6 +4412,7 @@ exports.useNamespaceIdentity = useNamespaceIdentity;
|
|
|
3042
4412
|
exports.useNamespaces = useNamespaces;
|
|
3043
4413
|
exports.useNamespacesForApplication = useNamespacesForApplication;
|
|
3044
4414
|
exports.useNodeIdentity = useNodeIdentity;
|
|
4415
|
+
exports.useRedeemInvitation = useRedeemInvitation;
|
|
3045
4416
|
exports.useRemoveGroupMembers = useRemoveGroupMembers;
|
|
3046
4417
|
exports.useReparentGroup = useReparentGroup;
|
|
3047
4418
|
exports.useResyncContext = useResyncContext;
|