git.iko.soy/bridge
on 703ff86 help sign in
bridge/src/lib/useKeyfileGenerator.ts
255 lines 7.3 kB history raw
1import { useCallback, useMemo, useEffect, useState } from 'react';
2import { Just } from 'folktale/maybe';
3import saveAs from 'file-saver';
4import { useWallet } from 'store/wallet';
5import { EMPTY_POINT, useRollerStore } from 'store/rollerStore';
6import { generateCode } from 'lib/networkCode';
7import {
8 attemptNetworkSeedDerivation,
9 deriveNetworkSeedFromUrbitWallet,
10 keysMatchChain,
11 deriveNetworkKeys,
12 compileMultiKey,
13} from './keys';
14import { stripSigPrefix } from 'form/formatters';
15import useRoller from './useRoller';
16import Point from './types/Point';
17import { toL1Details } from './utils/point';
18import { ETH_ZERO_ADDR } from './constants';
20interface useKeyfileGeneratorArgs {
21 point?: Point;
22 seeds: string[];
25/**
26 * The default Keyfile Generator. Can be used by itself, or composed with
27 * other hooks (see `useActivationKeyfileGenerator` and
28 * `useSingleKeyfileGenerator`).
29 *
30 * @param point Point - (optional) the Point for which to generate keys
31 * @param seeds string[] - (required) one or more seeds consumed by deriveNetworkKeys
32 *
33 */
34function useKeyfileGenerator({ point, seeds }: useKeyfileGeneratorArgs) {
35 // exported keyfile generator properties
36 const [notice, setNotice] = useState('Deriving networking keys...');
37 const [downloaded, setDownloaded] = useState(false);
38 const [generating, setGenerating] = useState(true);
39 const [keyfile, setKeyfile] = useState<boolean | string>(false);
40 const [code, setCode] = useState(false);
42 // resolved point
43 const { point: storedPoint } = useRollerStore();
44 const resolvedPoint = useMemo(() => {
45 return point || storedPoint;
46 }, [point, storedPoint]);
48 const networkRevision = useMemo(() => {
49 return Number(resolvedPoint.keyRevisionNumber);
50 }, [resolvedPoint]);
51 const canManage = useMemo(() => {
52 return resolvedPoint.isOwner || resolvedPoint.isManagementProxy;
53 }, [resolvedPoint]);
55 const hasNetworkKeys = networkRevision > 0;
56 const available = canManage && hasNetworkKeys && !!keyfile;
58 const generate = useCallback(async () => {
59 // Point still loading ...
60 if (resolvedPoint.value === EMPTY_POINT.value) {
61 return;
62 }
64 if (!hasNetworkKeys) {
65 setGenerating(false);
66 setNotice('Network keys not yet set.');
67 console.log(
68 `no networking keys available for revision ${networkRevision}`
69 );
70 return;
71 }
73 // seeds were either generated non-deterministically,
74 // or still being derived ...
75 if (seeds.length === 0) {
76 setGenerating(false);
77 setNotice(
78 'Custom or nondeterministic networking keys cannot be re-downloaded.'
79 );
80 console.log(`seed is nondeterminable for revision ${networkRevision}`);
81 return;
82 }
84 const pairs = seeds.map(seed => deriveNetworkKeys(seed));
85 const firstPair = pairs[0];
87 if (!keysMatchChain(firstPair, resolvedPoint)) {
88 setGenerating(false);
89 setNotice('Derived networking keys do not match on-chain details.');
90 console.log(`keys do not match details for revision ${networkRevision}`);
91 return;
92 }
94 setNotice('');
95 setCode(generateCode(firstPair));
96 setKeyfile(
97 compileMultiKey(
98 resolvedPoint.value,
99 pairs.map((pair, k) => {
100 return { revision: networkRevision + k, pair };
101 })
102 )
103 );
104 setGenerating(false);
105 }, [hasNetworkKeys, seeds, resolvedPoint, networkRevision]);
107 const filename = useMemo(() => {
108 return `${stripSigPrefix(resolvedPoint.patp)}-${networkRevision}.key`;
109 }, [resolvedPoint, networkRevision]);
111 const download = useCallback(() => {
112 if (typeof keyfile !== 'string') {
113 return;
114 }
116 saveAs(
117 new Blob([keyfile], {
118 type: 'text/plain;charset=utf-8',
119 }),
120 filename
121 );
122 setDownloaded(true);
123 }, [filename, keyfile]);
125 useEffect(() => {
126 generate();
127 }, [generate]);
129 const values = {
130 generating,
131 available,
132 downloaded,
133 download,
134 filename,
135 notice,
136 keyfile,
137 code,
138 };
140 return { ...values, bind: values };
143interface ActivationKeyfileGeneratorArgs {
144 pointId: number;
145 wallets: UrbitWallet[];
148/**
149 * This Activation Keyfile Generator is used to derive a multikey during the
150 * Activation Flow. At the time of generation, there is no Point yet set in
151 * the Roller Store, so we need to look it up by Point ID (to retreive the
152 * current key revision via API).
153 *
154 * @param pointId number - (required) the point ID for which to generate keys
155 * @param wallets UrbitWallet[] - (required) for each wallet,
156 * a seed + revision pair is generated and consumed by `compileMultiKey`.
157 * It should be an array of [deterministic invite wallet, non-deterministic
158 * master ticket wallet] (the sending and receiving wallets)
159 */
160export const useActivationKeyfileGenerator = ({
161 pointId,
162 wallets,
163}: ActivationKeyfileGeneratorArgs) => {
164 // resolve point
165 const { api } = useRoller();
166 const [point, setPoint] = useState<Point>(EMPTY_POINT);
168 const resolvePoint = useCallback(async () => {
169 const resolved = new Point({
170 value: pointId,
171 details: toL1Details(await api.getPoint(pointId)),
172 address: ETH_ZERO_ADDR,
173 });
175 setPoint(resolved);
176 }, [api, pointId]);
178 useEffect(() => {
179 resolvePoint();
180 }, [resolvePoint]);
182 // derive seeds from wallets
183 const [seeds, setSeeds] = useState<string[]>([]);
184 const deriveSeeds = useCallback(async () => {
185 if (!('keyRevisionNumber' in point)) {
186 return;
187 }
189 const derivedSeeds = await Promise.all(
190 wallets.map(async (w, i) => {
191 return deriveNetworkSeedFromUrbitWallet(w, point.keyRevisionNumber + i);
192 })
193 );
195 setSeeds(
196 derivedSeeds
197 .map(maybeSeed => maybeSeed.getOrElse(null))
198 .filter(s => s !== null)
199 );
200 }, [point, wallets]);
202 useEffect(() => {
203 deriveSeeds();
204 // eslint-disable-next-line react-hooks/exhaustive-deps
205 }, [point]);
207 return useKeyfileGenerator({ point, seeds });
208};
210interface SingleKeyfileGeneratorArgs {
211 seed?: string;
214/**
215 * This Single Keyfile Generator is used to derive network keys in multiple
216 * views in the Bridge dashboard (Set Network Keys, Home > ID, Home > OS).
217 * By default, it uses the logged in wallet's seed phrase.
218 *
219 * * @param seed string - (optional) default: provided by the logged in wallet
220 */
221export const useSingleKeyfileGenerator = ({
222 seed,
223}: SingleKeyfileGeneratorArgs) => {
224 // use provided seed, or fallback to deriving from logged in wallet
225 const { point } = useRollerStore();
226 const { authMnemonic, authToken, urbitWallet, wallet }: any = useWallet();
227 const [seeds, setSeeds] = useState<string[]>([]);
229 const deriveSeeds = useCallback(async () => {
230 if (seed) {
231 setSeeds([seed]);
232 return;
233 }
235 const derivedSeed = await attemptNetworkSeedDerivation({
236 urbitWallet,
237 wallet,
238 authMnemonic,
239 details: point,
240 authToken,
241 point: point.value,
242 revision: point.keyRevisionNumber,
243 });
245 if (Just.hasInstance(derivedSeed)) {
246 setSeeds([derivedSeed.value]);
247 }
248 }, [authMnemonic, authToken, point, seed, urbitWallet, wallet]);
250 useEffect(() => {
251 deriveSeeds();
252 }, [deriveSeeds]);
254 return useKeyfileGenerator({ seeds });
255};