git.iko.soy/bridge
on 2d3487f help sign in
bridge/src/lib/utils/roller.ts
196 lines 4.9 kB history raw
1import { signTransactionHash } from 'lib/authToken';
2import { Invite } from 'lib/types/Invite';
3import { Just, Nothing } from 'folktale/maybe';
4import { randomHex } from 'web3-utils';
6import {
7 Proxy,
8 Signature,
9 From,
10 EthAddress,
11 AddressParams,
12 Ship,
13} from '@urbit/roller-api';
15import { deriveNetworkKeys, CRYPTO_SUITE_VERSION } from 'lib/keys';
16import { addHexPrefix } from 'lib/utils/address';
17import { makeDeterministicTicket, generateWallet } from 'lib/walletgen';
19export const SECOND = 1000;
20export const MINUTE = SECOND * 60;
21export const HOUR = MINUTE * 60;
23export const padZero = (amount: number) =>
24 `${amount < 10 && amount > 0 ? '0' : ''}${amount}`;
26export const getTimeToNextBatch = (nextBatch: number, now: number) => {
27 const toNext = nextBatch - now;
28 const hours = Math.floor(toNext / HOUR);
29 const minutes = Math.floor((toNext - hours * HOUR) / MINUTE);
30 const seconds = Math.floor(
31 (toNext - hours * HOUR - minutes * MINUTE) / SECOND
32 );
34 return `${padZero(hours)}h ${padZero(minutes)}m ${padZero(seconds)}s`;
35};
37export const isL2 = (dom?: string) => dom === 'l2' || dom === 'spawn';
39export const isL2Spawn = (dom?: string) => dom === 'spawn';
41export const generateInviteWallet = async (point: number, seed: string) => {
42 const ticket = makeDeterministicTicket(point, seed);
43 const inviteWallet = await generateWallet(point, ticket, true);
45 return { ticket, inviteWallet };
46};
48export const spawn = async (
49 api: any,
50 _wallet: any,
51 _point: number,
52 proxy: string,
53 nonce: number,
54 planet: number
55) => {
56 const from = {
57 ship: _point, //ship that is spawning the planet
58 proxy,
59 };
61 const data = {
62 address: _wallet.address,
63 ship: planet, // ship to spawn
64 };
66 const hash = await api.hashTransaction(nonce, from, 'spawn', data);
67 const sSig = signTransactionHash(hash, _wallet.privateKey);
68 return api.spawn(sSig, from, _wallet.address, data);
69};
71export const configureKeys = async (
72 api: any,
73 wallet: any,
74 point: Ship,
75 proxy: string,
76 nonce: number,
77 networkSeed: any,
78 breach?: boolean
79) => {
80 const from = {
81 ship: point, //ship to configure keys
82 proxy,
83 };
85 // TODO: do something here?
86 if (Nothing.hasInstance(networkSeed)) {
87 console.log("Network key Error: couldn't derive network keys");
88 // throw new Error("Network key Error: couldn't derive network keys");
89 }
91 const seed = Just.hasInstance(networkSeed)
92 ? networkSeed.value
93 : randomHex(32);
95 const pair = deriveNetworkKeys(seed);
97 const data = {
98 encrypt: addHexPrefix(pair.crypt.public),
99 auth: addHexPrefix(pair.auth.public),
100 cryptoSuite: String(CRYPTO_SUITE_VERSION),
101 breach,
102 };
104 const hash = await api.hashTransaction(nonce, from, 'configureKeys', data);
105 const sig = signTransactionHash(hash, wallet.privateKey);
106 return api.configureKeys(sig, from, wallet.address, data);
107};
109export const transferPointRequest = async (
110 api: any,
111 _wallet: any,
112 _point: Ship,
113 proxy: string,
114 nonce: number,
115 address: string,
116 reset?: boolean
117) => {
118 const from = {
119 ship: _point, // ship to transfer
120 proxy,
121 };
123 const data = {
124 address,
125 reset: reset || false,
126 };
127 const hash = await api.hashTransaction(nonce, from, 'transferPoint', data);
128 const sig = signTransactionHash(hash, _wallet.privateKey);
129 return api.transferPoint(sig, from, _wallet.address, data);
130};
132const proxyType = (proxy: Proxy) => {
133 switch (proxy) {
134 case 'manage':
135 return 'setManagementProxy';
136 case 'spawn':
137 return 'setSpawnProxy';
138 case 'transfer':
139 return 'setTransferProxy';
140 default:
141 throw new Error(`Unknown proxyType ${proxy}`);
142 }
143};
145export const registerProxyAddress = async (
146 api: any,
147 _wallet: any,
148 _point: Ship,
149 proxy: string,
150 proxyAddressType: string,
151 nonce: number,
152 address: string
153) => {
154 const from = {
155 ship: _point,
156 proxy,
157 };
158 const managementData = { address };
159 const managementHash = await api.hashTransaction(
160 nonce,
161 from,
162 proxyType(proxyAddressType),
163 managementData
164 );
165 return setProxy(
166 api,
167 proxyAddressType,
168 signTransactionHash(managementHash, _wallet.privateKey),
169 from,
170 _wallet.address,
171 managementData
172 );
173};
175const setProxy = async (
176 api: any,
177 proxyAddressType: string,
178 sig: Signature,
179 from: From,
180 address: EthAddress,
181 data: AddressParams
182) => {
183 switch (proxyAddressType) {
184 case 'manage':
185 return await api.setManagementProxy(sig, from, address, data);
186 case 'spawn':
187 return await api.setSpawnProxy(sig, from, address, data);
188 case 'transfer':
189 return await api.setTrasferProxy(sig, from, address, data);
190 default:
191 throw new Error(`Unknown proxyType ${proxyAddressType}`);
192 }
193};
195export const hasPoint = (point: number) => (invite: Invite) =>
196 invite.planet === point;