src/lib/utils/roller.ts · bridge

git.iko.soy/bridge

on 73ef2e5 help sign in

bridge/src/lib/utils/roller.ts

373 lines 9.1 kB history raw

1import { Just, Nothing } from 'folktale/maybe';

2import { randomHex } from 'web3-utils';

3import WalletConnect from '@walletconnect/client';

4import RollerRPCAPI, {

5 Proxy,

6 Signature,

7 From,

8 EthAddress,

9 AddressParams,

10 Ship,

11 SpawnParams,

12 L2Data,

13 PendingTransaction,

14} from '@urbit/roller-api';

16import { Invite } from 'lib/types/Invite';

17import { signTransactionHash } from 'lib/authToken';

18import { deriveNetworkKeys, CRYPTO_SUITE_VERSION } from 'lib/keys';

19import { addHexPrefix } from 'lib/utils/address';

20import { makeDeterministicTicket, generateWallet } from 'lib/walletgen';

21import { WALLET_TYPES } from 'lib/constants';

22import { L2TransactionArgs, TransactionData } from 'lib/types/L2Transaction';

24export const SECOND = 1000;

25export const MINUTE = SECOND * 60;

26export const HOUR = MINUTE * 60;

28export const padZero = (amount: number) =>

29 `${amount < 10 && amount >= 0 ? '0' : ''}${amount}`;

31export const hasPoint = (point: number) => (invite: Invite) =>

32 invite.planet === point;

34export const getTimeToNextBatch = (nextBatch: number, now: number) => {

35 const toNext = Math.max(nextBatch - now, 0);

36 const hours = Math.floor(toNext / HOUR);

37 const minutes = Math.floor((toNext - hours * HOUR) / MINUTE);

38 const seconds = Math.floor(

39 (toNext - hours * HOUR - minutes * MINUTE) / SECOND

40 );

42 return `${padZero(hours)}h ${padZero(minutes)}m ${padZero(seconds)}s`;

43};

45export const isL2 = (dom?: string) => dom === 'l2';

47export const isL2Spawn = (dom?: string) => dom === 'l2' || dom === 'spawn';

49export const generateInviteWallet = async (point: number, seed: string) => {

50 const ticket = makeDeterministicTicket(point, seed);

51 const inviteWallet = await generateWallet(point, ticket, true);

53 return { ticket, inviteWallet };

54};

56export const generateHashAndSign = async (

57 api: RollerRPCAPI,

58 wallet: any,

59 nonce: number,

60 from: From,

61 type: string,

62 data: any,

63 walletType: symbol,

64 web3: any,

65 connector: WalletConnect | null

66) => {

67 if (walletType === WALLET_TYPES.METAMASK) {

68 const hash = await api.prepareForSigning(nonce, from, type, data);

69 const sig = await web3.eth.personal.sign(hash, wallet.address, '');

70 return sig;

71 } else if (walletType === WALLET_TYPES.WALLET_CONNECT) {

72 if (!connector || !connector.connected) {

73 throw new Error('Awaiting WalletConnect connection...');

74 }

76 const hash = await api.prepareForSigning(nonce, from, type, data);

77 const sig = await connector.signPersonalMessage([hash, wallet.address]);

78 return sig;

79 } else {

80 const hash = await api.getUnsignedTx(nonce, from, type, data);

81 const sig = await signTransactionHash(hash, wallet.privateKey);

82 return sig;

83 }

84};

86export const configureKeys = async (

87 api: RollerRPCAPI,

88 wallet: any,

89 point: Ship,

90 proxy: string,

91 nonce: number,

92 networkSeed: any,

93 walletType: symbol,

94 web3: any,

95 connector: WalletConnect | null,

96 breach?: boolean,

97 force: boolean = false

98) => {

99 const from = {

100 ship: point, //ship to configure keys

101 proxy,

102 };

103

104 // TODO: do something here?

105 if (Nothing.hasInstance(networkSeed)) {

106 console.log("Network key Error: couldn't derive network keys");

107 // throw new Error("Network key Error: couldn't derive network keys");

108 }

109

110 const seed = Just.hasInstance(networkSeed)

111 ? networkSeed.value

112 : randomHex(32);

113

114 const pair = deriveNetworkKeys(seed);

115

116 const data = {

117 encrypt: addHexPrefix(pair.crypt.public),

118 auth: addHexPrefix(pair.auth.public),

119 cryptoSuite: String(CRYPTO_SUITE_VERSION),

120 breach: breach || false,

121 };

122

123 const sig = await generateHashAndSign(

124 api,

125 wallet,

126 nonce,

127 from,

128 'configureKeys',

129 data,

130 walletType,

131 web3,

132 connector

133 );

134 return api.configureKeys(sig, force, from, wallet.address, data);

135};

136

137export const transferPointRequest = async (

138 api: RollerRPCAPI,

139 wallet: any,

140 pointToTransfer: Ship,

141 proxy: string,

142 nonce: number,

143 address: string,

144 walletType: symbol,

145 web3: any,

146 connector: WalletConnect | null,

147 reset?: boolean,

148 force: boolean = false

149) => {

150 const from = {

151 ship: pointToTransfer,

152 proxy,

153 };

154

155 const data = {

156 address,

157 reset: reset || false,

158 };

159

160 const sig = await generateHashAndSign(

161 api,

162 wallet,

163 nonce,

164 from,

165 'transferPoint',

166 data,

167 walletType,

168 web3,

169 connector

170 );

171

172 return api.transferPoint(sig, force, from, wallet.address, data);

173};

174

175const proxyType = (proxy: Proxy) => {

176 switch (proxy) {

177 case 'manage':

178 return 'setManagementProxy';

179 case 'spawn':

180 return 'setSpawnProxy';

181 case 'transfer':

182 return 'setTransferProxy';

183 default:

184 throw new Error(`Unknown proxyType ${proxy}`);

185 }

186};

187

188const setProxy = async (

189 api: RollerRPCAPI,

190 proxyAddressType: string,

191 sig: Signature,

192 from: From,

193 address: EthAddress,

194 data: AddressParams,

195 force: boolean = false

196) => {

197 switch (proxyAddressType) {

198 case 'manage':

199 return await api.setManagementProxy(sig, force, from, address, data);

200 case 'spawn':

201 return await api.setSpawnProxy(sig, force, from, address, data);

202 case 'transfer':

203 return await api.setTransferProxy(sig, force, from, address, data);

204 default:

205 throw new Error(`Unknown proxyType ${proxyAddressType}`);

206 }

207};

208

209export const registerProxyAddress = async (

210 api: RollerRPCAPI,

211 wallet: any, // BridgeWallet

212 _point: Ship,

213 proxy: string,

214 proxyAddressType: string,

215 nonce: number,

216 address: string,

217 walletType: symbol,

218 web3: any,

219 connector: WalletConnect | null,

220 force?: boolean

221) => {

222 const from = {

223 ship: _point,

224 proxy,

225 };

226 const data = { address };

227

228 const sig = await generateHashAndSign(

229 api,

230 wallet,

231 nonce,

232 from,

233 proxyType(proxyAddressType),

234 data,

235 walletType,

236 web3,

237 connector

238 );

239

240 return setProxy(

241 api,

242 proxyAddressType,

243 sig,

244 from,

245 wallet.address,

246 data,

247 force

248 );

249};

250

251const getDataAndMethod = (args: L2TransactionArgs) => {

252 const {

253 address,

254 api,

255 breach,

256 networkSeed,

257 reset,

258 pointToSpawn,

259 newSponsor,

260 sponsee,

261 ship,

262 } = args;

263 const result: TransactionData = { data: { address }, method: () => null };

264

265 switch (args.type) {

266 case 'transferPoint':

267 result.method = api.transferPoint;

268 result.data.reset = reset || false;

269 return result;

270 case 'spawn':

271 result.method = api.spawn;

272 result.data.ship = pointToSpawn;

273 return result;

274 case 'configureKeys':

275 // TODO: do something here?

276 if (Nothing.hasInstance(networkSeed)) {

277 console.log("Network key Error: couldn't derive network keys");

278 // throw new Error("Network key Error: couldn't derive network keys");

279 }

280

281 const seed = Just.hasInstance(networkSeed)

282 ? networkSeed.value

283 : randomHex(32);

284

285 const pair = deriveNetworkKeys(seed);

286

287 result.data = {

288 encrypt: addHexPrefix(pair.crypt.public),

289 auth: addHexPrefix(pair.auth.public),

290 cryptoSuite: String(CRYPTO_SUITE_VERSION),

291 breach: breach || false,

292 };

293 result.method = api.configureKeys;

294 return result;

295 case 'escape':

296 result.method = api.escape;

297 result.data.ship = newSponsor;

298 delete result.data.address;

299 return result;

300 case 'cancelEscape':

301 result.method = api.cancelEscape;

302 result.data.ship = ship;

303 delete result.data.address;

304 return result;

305 case 'adopt':

306 result.method = api.adopt;

307 result.data.ship = sponsee;

308 delete result.data.address;

309 return result;

310 case 'detach':

311 result.method = api.detach;

312 result.data.ship = sponsee;

313 delete result.data.address;

314 return result;

315 case 'reject':

316 result.method = api.reject;

317 result.data.ship = sponsee;

318 delete result.data.address;

319 return result;

320 }

321};

322

323export const submitL2Transaction = async (args: L2TransactionArgs) => {

324 const {

325 api,

326 wallet,

327 ship,

328 type,

329 proxy,

330 nonce,

331 walletType,

332 web3,

333 connector,

334 } = args;

335

336 const from = { ship, proxy };

337 const { data, method } = getDataAndMethod(args);

338

339 const sig = await generateHashAndSign(

340 api,

341 wallet,

342 nonce,

343 from,

344 type,

345 data,

346 walletType,

347 web3,

348 connector

349 );

350

351 return method(sig, from, wallet.address, data);

352};

353

354export const reticketL2Point = async () => {};

355

356export const hasInvite = (point: number) => (invite: Invite) =>

357 invite.planet === point && invite.ticket.length > 0;

358

359function isSpawn(tx: L2Data | undefined): tx is SpawnParams {

360 return (tx as SpawnParams) !== undefined;

361}

362

363function isShipNumber(ship: number | string | undefined): ship is number {

364 return (ship as number) !== undefined;

365}

366

367export const getPendingSpawns = (pendingTxs: PendingTransaction[]) =>

368 pendingTxs.reduce((acc, pending) => {

369 return isSpawn(pending.rawTx?.tx) &&

370 isShipNumber(pending.rawTx?.tx.data.ship)

371 ? acc.add(pending.rawTx?.tx.data.ship!)

372 : acc;

373 }, new Set<number>());