git.iko.soy/bridge
on 261ea40 help sign in
bridge/src/lib/keys.js
195 lines 4.5 kB history raw
1import BN from 'bn.js';
2import { Just, Nothing } from 'folktale/maybe';
4import * as noun from '../nockjs/noun';
5import * as serial from '../nockjs/serial';
6import * as kg from 'urbit-key-generation/dist';
8import { eqAddr, addHexPrefix } from './wallet';
10// the curve param for the network keys
11export const NETWORK_KEY_CURVE_PARAMETER = '42';
12// the current crypto suite version
13export const CRYPTO_SUITE_VERSION = 1;
15export const CURVE_ZERO_ADDR =
16 '0x0000000000000000000000000000000000000000000000000000000000000000';
18// ctsy joemfb
19const b64 = buf => {
20 let hex = buf.reverse().toString('hex');
21 let n = new BN(hex, 'hex');
22 let c = [];
23 while (1 === n.cmpn(0)) {
24 c.push(n.andln(0x3f));
25 n = n.shrn(6);
26 }
28 // prettier-ignore
29 const trans = j =>
30 10 > j
31 ? j + 48
32 : 36 > j
33 ? j + 87
34 : 62 > j
35 ? j + 29
36 : 62 === j
37 ? 45
38 : 126;
40 return (
41 '0w' +
42 c.reduce(
43 (a, b, i) =>
44 String.fromCharCode(trans(b)) + (i && 0 === i % 5 ? '.' : '') + a,
45 ''
46 )
47 );
48};
50const jam = seed => {
51 const hex = serial
52 .jam(seed)
53 .toString()
54 .slice(2);
55 const pad = hex.length % 2 === 0 ? hex : '0' + hex;
56 return Buffer.from(pad, 'hex').reverse();
57};
59// simple alias to avoid importing kg into component scope
60export const deriveNetworkKeys = seed => kg.deriveNetworkKeys(seed);
62/**
63 * @param {object} pair
64 * @param {number} point
65 * @param {number} revision
66 * @return {string}
67 */
68export const compileNetworkingKey = (pair, point, revision) => {
69 const bnsec = new BN(
70 pair.crypt.private + pair.auth.private + NETWORK_KEY_CURVE_PARAMETER,
71 'hex'
72 );
74 const sed = noun.dwim(
75 noun.Atom.fromInt(point),
76 noun.Atom.fromInt(revision),
77 noun.Atom.fromString(bnsec.toString()),
78 noun.Atom.yes
79 );
81 return b64(jam(sed));
82};
84/**
85 * @param {object} urbitWallet
86 * @param {number} revision
87 * @return {Promise<Maybe<string>>}
88 */
89export const deriveNetworkSeedFromUrbitWallet = async (
90 urbitWallet,
91 revision = 1
92) => {
93 return await deriveNetworkSeedFromMnemonic(
94 urbitWallet.management.seed,
95 urbitWallet.meta.passphrase,
96 revision
97 );
98};
100/**
101 * @param {Maybe<any>} wallet
102 * @param {string} authMnemonic
103 * @param {object} details
104 * @param {number} revision
105 * @return {Promise<Maybe<string>>}
106 */
107export const deriveNetworkSeedFromManagementMnemonic = async (
108 wallet,
109 authMnemonic,
110 details,
111 revision = 1
112) => {
113 const isManagementProxy = eqAddr(wallet.address, details.managementProxy);
115 // the network seed is derivable iff this mnemonic is the management proxy
116 if (isManagementProxy) {
117 return await deriveNetworkSeedFromMnemonic(
118 authMnemonic,
119 wallet.passphrase,
120 revision
121 );
122 }
124 return Nothing();
125};
127/**
128 * @param {string} mnemonic
129 * @param {string} passphrase
130 * @param {number} revision
131 * @return {Promise<Maybe<string>>}
132 */
133const deriveNetworkSeedFromMnemonic = async (
134 mnemonic,
135 passphrase,
136 revision
137) => {
138 //NOTE revision is the point's on-chain revision number. since common uhdw
139 // usage derives the first key at revision/index 0, we need to decrement
140 // the on-chain revision number by one to get the number to derive with.
141 return Just(await kg.deriveNetworkSeed(mnemonic, passphrase, revision - 1));
142};
144/**
145 * @return {Promise<Maybe<string>>}
146 */
147export const attemptNetworkSeedDerivation = async ({
148 urbitWallet,
149 wallet,
150 authMnemonic,
151 details,
152 revision,
153}) => {
154 if (Just.hasInstance(urbitWallet)) {
155 return await deriveNetworkSeedFromUrbitWallet(urbitWallet.value, revision);
156 }
158 if (Just.hasInstance(wallet) && Just.hasInstance(authMnemonic)) {
159 return await deriveNetworkSeedFromManagementMnemonic(
160 wallet.value,
161 authMnemonic.value,
162 details,
163 revision
164 );
165 }
167 return Nothing();
168};
170/**
171 *
172 * @param {object} pair
173 * @param {object} details
174 * @return {boolean}
175 */
176export const keysMatchChain = (pair, details) => {
177 const { crypt, auth } = pair;
178 const { encryptionKey, authenticationKey } = details;
180 return (
181 encryptionKey === addHexPrefix(crypt.public) &&
182 authenticationKey === addHexPrefix(auth.public)
183 );
184};
186export const segmentNetworkKey = hex => {
187 if (hex === CURVE_ZERO_ADDR) {
188 return null;
189 }
191 const sl = i => hex.slice(i, i + 4);
192 const rowFrom = i => `${sl(i)}.${sl(i + 4)}.${sl(i + 8)}.${sl(i + 12)}`;
194 return [rowFrom(2), rowFrom(18), rowFrom(34), rowFrom(50)];
195};