git.iko.soy/bridge
on 67d9ca6 help sign in
bridge/src/lib/utils/roller.ts
198 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 {
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 generateInviteWallet = async (point: number, seed: string) => {
44 const ticket = makeDeterministicTicket(point, seed);
45 const inviteWallet = await generateWallet(point, ticket, true);
47 return { ticket, inviteWallet };
48};
50export const spawn = async (
51 api: any,
52 _wallet: any,
53 _point: number,
54 proxy: string,
55 nonce: number,
56 planet: number
57) => {
58 const from = {
59 ship: _point, //ship that is spawning the planet
60 proxy,
61 };
63 const data = {
64 address: _wallet.address,
65 ship: planet, // ship to spawn
66 };
68 const hash = await api.hashTransaction(nonce, from, 'spawn', data);
69 const sSig = signTransactionHash(hash, _wallet.privateKey);
70 return api.spawn(sSig, from, _wallet.address, data);
71};
73export const configureKeys = async (
74 api: any,
75 _wallet: any,
76 _point: number,
77 proxy: string,
78 nonce: number,
79 urbitWallet: any
80) => {
81 const from = {
82 ship: _point, //ship to configure keys
83 proxy,
84 };
86 const networkSeed = await deriveNetworkSeedFromUrbitWallet(urbitWallet, 1);
87 // TODO: do something here?
88 if (Nothing.hasInstance(networkSeed)) {
89 console.log("Network key Error: couldn't derive network keys");
90 // throw new Error("Network key Error: couldn't derive network keys");
91 }
93 const seed = Just.hasInstance(networkSeed)
94 ? networkSeed.value
95 : randomHex(32);
97 const pair = deriveNetworkKeys(seed);
99 const data = {
100 encrypt: addHexPrefix(pair.crypt.public),
101 auth: addHexPrefix(pair.auth.public),
102 cryptoSuite: String(CRYPTO_SUITE_VERSION),
103 breach: false,
104 };
106 const hash = await api.hashTransaction(nonce, from, 'configureKeys', data);
107 const sig = signTransactionHash(hash, _wallet.privateKey);
108 return api.configureKeys(sig, from, _wallet.address, data);
109};
111export const transferPoint = async (
112 api: any,
113 _wallet: any,
114 _point: number,
115 proxy: string,
116 nonce: number,
117 address: string
118) => {
119 const from = {
120 ship: _point, // ship to transfer
121 proxy,
122 };
124 const data = {
125 address,
126 reset: false,
127 };
129 const hash = await api.hashTransaction(nonce, from, 'transferPoint', data);
130 const sig = signTransactionHash(hash, _wallet.privateKey);
131 return api.transferPoint(sig, from, _wallet.address, data);
132};
134const proxyType = (proxy: Proxy) => {
135 switch (proxy) {
136 case 'manage':
137 return 'setManagementProxy';
138 case 'spawn':
139 return 'setSpawnProxy';
140 case 'transfer':
141 return 'setTransferProxy';
142 default:
143 throw new Error(`Unknown proxyType ${proxy}`);
144 }
145};
147export const registerProxyAddress = async (
148 api: any,
149 _wallet: any,
150 _point: Ship,
151 proxy: string,
152 proxyAddressType: string,
153 nonce: number,
154 address: string
155) => {
156 const from = {
157 ship: _point,
158 proxy,
159 };
160 const managementData = { address };
161 const managementHash = await api.hashTransaction(
162 nonce,
163 from,
164 proxyType(proxyAddressType),
165 managementData
166 );
167 return setProxy(
168 api,
169 proxyAddressType,
170 signTransactionHash(managementHash, _wallet.privateKey),
171 from,
172 _wallet.address,
173 managementData
174 );
175};
177const setProxy = async (
178 api: any,
179 proxyAddressType: string,
180 sig: Signature,
181 from: From,
182 address: EthAddress,
183 data: AddressParams
184) => {
185 switch (proxyAddressType) {
186 case 'manage':
187 return await api.setManagementProxy(sig, from, address, data);
188 case 'spawn':
189 return await api.setSpawnProxy(sig, from, address, data);
190 case 'transfer':
191 return await api.setTrasferProxy(sig, from, address, data);
192 default:
193 throw new Error(`Unknown proxyType ${proxyAddressType}`);
194 }
195};
197export const hasPoint = (point: number) => (invite: Invite) =>
198 invite.planet === point;