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
|
import {
AbsoluteTime,
Codec,
LockedAccount,
OfficerAccount,
OfficerId,
SigningKey,
buildCodecForObject,
codecForAbsoluteTime,
codecForString,
codecOptional,
createNewOfficerAccount,
decodeCrock,
encodeCrock,
unlockOfficerAccount,
} from "@gnu-taler/taler-util";
import {
buildStorageKey,
useLocalStorage,
useMemoryStorage,
} from "@gnu-taler/web-util/browser";
import { useMemo } from "preact/hooks";
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());
const ACCOUNT_KEY = "account";
export function useOfficer(): OfficerState {
// 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])
// const accountStorage = useMemoryStorage<OfficerAccount>(ACCOUNT_KEY);
// const account = accountStorage.value;
const officerStorage = useLocalStorage(OFFICER_KEY);
const officer = officerStorage.value;
if (officer === undefined) {
return {
state: "not-found",
create: async (pwd: string) => {
const { id, safe, signingKey } = await createNewOfficerAccount(pwd);
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();
},
};
}
|
