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