git.iko.soy/bridge
on a130fe4 help sign in
bridge/src/lib/utils/roller.ts
200 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 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: number,
79 proxy: string,
80 nonce: number,
81 urbitWallet: any
82) => {
83 const from = {
84 ship: _point, //ship to configure keys
85 proxy,
86 };
88 const networkSeed = await deriveNetworkSeedFromUrbitWallet(urbitWallet, 1);
89 // TODO: do something here?
90 if (Nothing.hasInstance(networkSeed)) {
91 console.log("Network key Error: couldn't derive network keys");
92 // throw new Error("Network key Error: couldn't derive network keys");
93 }
95 const seed = Just.hasInstance(networkSeed)
96 ? networkSeed.value
97 : randomHex(32);
99 const pair = deriveNetworkKeys(seed);
101 const data = {
102 encrypt: addHexPrefix(pair.crypt.public),
103 auth: addHexPrefix(pair.auth.public),
104 cryptoSuite: String(CRYPTO_SUITE_VERSION),
105 breach: false,
106 };
108 const hash = await api.hashTransaction(nonce, from, 'configureKeys', data);
109 const sig = signTransactionHash(hash, _wallet.privateKey);
110 return api.configureKeys(sig, from, _wallet.address, data);
111};
113export const transferPoint = async (
114 api: any,
115 _wallet: any,
116 _point: number,
117 proxy: string,
118 nonce: number,
119 address: string
120) => {
121 const from = {
122 ship: _point, // ship to transfer
123 proxy,
124 };
126 const data = {
127 address,
128 reset: false,
129 };
131 const hash = await api.hashTransaction(nonce, from, 'transferPoint', data);
132 const sig = signTransactionHash(hash, _wallet.privateKey);
133 return api.transferPoint(sig, from, _wallet.address, data);
134};
136const proxyType = (proxy: Proxy) => {
137 switch (proxy) {
138 case 'manage':
139 return 'setManagementProxy';
140 case 'spawn':
141 return 'setSpawnProxy';
142 case 'transfer':
143 return 'setTransferProxy';
144 default:
145 throw new Error(`Unknown proxyType ${proxy}`);
146 }
147};
149export const registerProxyAddress = async (
150 api: any,
151 _wallet: any,
152 _point: Ship,
153 proxy: string,
154 proxyAddressType: string,
155 nonce: number,
156 address: string
157) => {
158 const from = {
159 ship: _point,
160 proxy,
161 };
162 const managementData = { address };
163 const managementHash = await api.hashTransaction(
164 nonce,
165 from,
166 proxyType(proxyAddressType),
167 managementData
168 );
169 return setProxy(
170 api,
171 proxyAddressType,
172 signTransactionHash(managementHash, _wallet.privateKey),
173 from,
174 _wallet.address,
175 managementData
176 );
177};
179const setProxy = async (
180 api: any,
181 proxyAddressType: string,
182 sig: Signature,
183 from: From,
184 address: EthAddress,
185 data: AddressParams
186) => {
187 switch (proxyAddressType) {
188 case 'manage':
189 return await api.setManagementProxy(sig, from, address, data);
190 case 'spawn':
191 return await api.setSpawnProxy(sig, from, address, data);
192 case 'transfer':
193 return await api.setTrasferProxy(sig, from, address, data);
194 default:
195 throw new Error(`Unknown proxyType ${proxyAddressType}`);
196 }
197};
199export const hasPoint = (point: number) => (invite: Invite) =>
200 invite.planet === point;