git.iko.soy/bridge
on master help sign in
bridge/src/lib/useKeyfileGenerator.ts
256 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 resolvedPoint.continuityNumber,
100 pairs.map((pair, k) => {
101 return { revision: networkRevision + k, pair };
102 })
103 )
104 );
105 setGenerating(false);
106 }, [hasNetworkKeys, seeds, resolvedPoint, networkRevision]);
108 const filename = useMemo(() => {
109 return `${stripSigPrefix(resolvedPoint.patp)}-${networkRevision}.key`;
110 }, [resolvedPoint, networkRevision]);
112 const download = useCallback(() => {
113 if (typeof keyfile !== 'string') {
114 return;
115 }
117 saveAs(
118 new Blob([keyfile], {
119 type: 'text/plain;charset=utf-8',
120 }),
121 filename
122 );
123 setDownloaded(true);
124 }, [filename, keyfile]);
126 useEffect(() => {
127 generate();
128 }, [generate]);
130 const values = {
131 generating,
132 available,
133 downloaded,
134 download,
135 filename,
136 notice,
137 keyfile,
138 code,
139 };
141 return { ...values, bind: values };
144interface ActivationKeyfileGeneratorArgs {
145 pointId: number;
146 wallets: UrbitWallet[];
149/**
150 * This Activation Keyfile Generator is used to derive a multikey during the
151 * Activation Flow. At the time of generation, there is no Point yet set in
152 * the Roller Store, so we need to look it up by Point ID (to retreive the
153 * current key revision via API).
154 *
155 * @param pointId number - (required) the point ID for which to generate keys
156 * @param wallets UrbitWallet[] - (required) for each wallet,
157 * a seed + revision pair is generated and consumed by `compileMultiKey`.
158 * It should be an array of [deterministic invite wallet, non-deterministic
159 * master ticket wallet] (the sending and receiving wallets)
160 */
161export const useActivationKeyfileGenerator = ({
162 pointId,
163 wallets,
164}: ActivationKeyfileGeneratorArgs) => {
165 // resolve point
166 const { api } = useRoller();
167 const [point, setPoint] = useState<Point>(EMPTY_POINT);
169 const resolvePoint = useCallback(async () => {
170 const resolved = new Point({
171 value: pointId,
172 details: toL1Details(await api.getPoint(pointId)),
173 address: ETH_ZERO_ADDR,
174 });
176 setPoint(resolved);
177 }, [api, pointId]);
179 useEffect(() => {
180 resolvePoint();
181 }, [resolvePoint]);
183 // derive seeds from wallets
184 const [seeds, setSeeds] = useState<string[]>([]);
185 const deriveSeeds = useCallback(async () => {
186 if (!('keyRevisionNumber' in point)) {
187 return;
188 }
190 const derivedSeeds = await Promise.all(
191 wallets.map(async (w, i) => {
192 return deriveNetworkSeedFromUrbitWallet(w, point.keyRevisionNumber + i);
193 })
194 );
196 setSeeds(
197 derivedSeeds
198 .map(maybeSeed => maybeSeed.getOrElse(null))
199 .filter(s => s !== null)
200 );
201 }, [point, wallets]);
203 useEffect(() => {
204 deriveSeeds();
205 // eslint-disable-next-line react-hooks/exhaustive-deps
206 }, [point]);
208 return useKeyfileGenerator({ point, seeds });
209};
211interface SingleKeyfileGeneratorArgs {
212 seed?: string;
215/**
216 * This Single Keyfile Generator is used to derive network keys in multiple
217 * views in the Bridge dashboard (Set Network Keys, Home > ID, Home > OS).
218 * By default, it uses the logged in wallet's seed phrase.
219 *
220 * * @param seed string - (optional) default: provided by the logged in wallet
221 */
222export const useSingleKeyfileGenerator = ({
223 seed,
224}: SingleKeyfileGeneratorArgs) => {
225 // use provided seed, or fallback to deriving from logged in wallet
226 const { point } = useRollerStore();
227 const { authMnemonic, authToken, urbitWallet, wallet }: any = useWallet();
228 const [seeds, setSeeds] = useState<string[]>([]);
230 const deriveSeeds = useCallback(async () => {
231 if (seed) {
232 setSeeds([seed]);
233 return;
234 }
236 const derivedSeed = await attemptNetworkSeedDerivation({
237 urbitWallet,
238 wallet,
239 authMnemonic,
240 details: point,
241 authToken,
242 point: point.value,
243 revision: point.keyRevisionNumber,
244 });
246 if (Just.hasInstance(derivedSeed)) {
247 setSeeds([derivedSeed.value]);
248 }
249 }, [authMnemonic, authToken, point, seed, urbitWallet, wallet]);
251 useEffect(() => {
252 deriveSeeds();
253 }, [deriveSeeds]);
255 return useKeyfileGenerator({ seeds });
256};