1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
import {
AbsoluteTime,
Codec,
LockedAccount,
OfficerAccount,
OfficerId,
SigningKey,
buildCodecForObject,
codecForAbsoluteTime,
codecForString,
createNewOfficerAccount,
decodeCrock,
encodeCrock,
unlockOfficerAccount
} from "@gnu-taler/taler-util";
import {
buildStorageKey,
useLocalStorage
} from "@gnu-taler/web-util/browser";
import { useMemo } from "preact/hooks";
import { useMaybeExchangeApiContext } from "../context/config.js";
export interface Officer {
account: LockedAccount;
when: AbsoluteTime;
}
const codecForLockedAccount = codecForString() as Codec<LockedAccount>;
type OfficerAccountString = {
id: string,
strKey: string;
}
export const codecForOfficerAccount = (): Codec<OfficerAccountString> =>
buildCodecForObject<OfficerAccountString>()
.property("id", codecForString()) // FIXME
.property("strKey", codecForString()) // FIXME
.build("OfficerAccount");
export const codecForOfficer = (): Codec<Officer> =>
buildCodecForObject<Officer>()
.property("account", codecForLockedAccount) // FIXME
.property("when", codecForAbsoluteTime) // FIXME
.build("Officer");
export type OfficerState = OfficerNotReady | OfficerReady;
export type OfficerNotReady = OfficerNotFound | OfficerLocked;
interface OfficerNotFound {
state: "not-found";
create: (password: string) => Promise<void>;
}
interface OfficerLocked {
state: "locked";
forget: () => void;
tryUnlock: (password: string) => Promise<void>;
}
interface OfficerReady {
state: "ready";
account: OfficerAccount;
forget: () => void;
lock: () => void;
}
const OFFICER_KEY = buildStorageKey("officer", codecForOfficer());
const DEV_ACCOUNT_KEY = buildStorageKey("account-dev", codecForOfficerAccount());
export function useOfficer(): OfficerState {
const exchangeContext = useMaybeExchangeApiContext();
// dev account, is save when reloaded.
const accountStorage = useLocalStorage(DEV_ACCOUNT_KEY);
const account = useMemo(() => {
if (!accountStorage.value) return undefined
return {
id: accountStorage.value.id as OfficerId,
signingKey: decodeCrock(accountStorage.value.strKey) as SigningKey
}
}, [accountStorage.value?.id, accountStorage.value?.strKey])
const officerStorage = useLocalStorage(OFFICER_KEY);
const officer = useMemo(() => {
if (!officerStorage.value) return undefined
return officerStorage.value
}, [officerStorage.value?.account, officerStorage.value?.when.t_ms])
if (officer === undefined) {
return {
state: "not-found",
create: async (pwd: string) => {
if (!exchangeContext) return;
const req = await fetch(new URL("seed", exchangeContext.api.baseUrl).href)
const b = await req.blob()
const ar = await b.arrayBuffer()
const uintar = new Uint8Array(ar)
const { id, safe, signingKey } = await createNewOfficerAccount(pwd, uintar);
officerStorage.update({
account: safe,
when: AbsoluteTime.now(),
});
// accountStorage.update({ id, signingKey });
const strKey = encodeCrock(signingKey)
accountStorage.update({ id, strKey })
},
};
}
if (account === undefined) {
return {
state: "locked",
forget: () => {
officerStorage.reset();
},
tryUnlock: async (pwd: string) => {
const ac = await unlockOfficerAccount(officer.account, pwd);
// accountStorage.update(ac);
accountStorage.update({ id: ac.id, strKey: encodeCrock(ac.signingKey) })
},
};
}
return {
state: "ready",
account,
lock: () => {
accountStorage.reset();
},
forget: () => {
officerStorage.reset();
accountStorage.reset();
},
};
}
|
