git.iko.soy/bridge
on d6d11df help sign in
bridge/src/lib/txn.js
247 lines 6.8 kB history raw
1import * as ob from 'urbit-ob';
2import { Just } from 'folktale/maybe';
3import Tx from 'ethereumjs-tx';
4import { toWei, fromWei, toHex } from 'web3-utils';
5import * as retry from 'async-retry';
7import { BRIDGE_ERROR } from './error';
8import { NETWORK_TYPES } from './network';
9import { ledgerSignTransaction } from './ledger';
10import { trezorSignTransaction } from './trezor';
11import { WALLET_TYPES, addHexPrefix } from './wallet';
13const CHECK_BLOCK_EVERY_MS =
14 process.env.NODE_ENV === 'development' ? 1000 : 5000;
16const RETRY_OPTIONS = {
17 retries: 99999,
18 factor: 1,
19 minTimeout: CHECK_BLOCK_EVERY_MS,
20 randomize: false,
21};
23const TXN_PURPOSE = {
24 SET_MANAGEMENT_PROXY: Symbol('SET_MANAGEMENT_PROXY'),
25 SET_TRANSFER_PROXY: Symbol('SET_TRANSFER_PROXY'),
26 SET_SPAWN_PROXY: Symbol('SET_SPAWN_PROXY'),
27 CREATE_GALAXY: Symbol('CREATE_GALAXY'),
28 ISSUE_CHILD: Symbol('ISSUE_CHILD'),
29 SET_KEYS: Symbol('SET_KEYS'),
30 TRANSFER: Symbol('TRANSFER'),
31 CANCEL_TRANSFER: Symbol('CANCEL_TRANSFER'),
32};
34const renderTxnPurpose = purpose =>
35 purpose === TXN_PURPOSE.SET_MANAGEMENT_PROXY
36 ? 'set this management proxy'
37 : purpose === TXN_PURPOSE.SET_SPAWN_PROXY
38 ? 'set this spawn proxy'
39 : purpose === TXN_PURPOSE.SET_TRANSFER_PROXY
40 ? 'set this transfer proxy'
41 : purpose === TXN_PURPOSE.CREATE_GALAXY
42 ? 'create this galaxy'
43 : purpose === TXN_PURPOSE.ISSUE_CHILD
44 ? 'issue this point'
45 : purpose === TXN_PURPOSE.SET_KEYS
46 ? 'set these network keys'
47 : purpose === TXN_PURPOSE.TRANSFER
48 ? 'transfer this point'
49 : purpose === TXN_PURPOSE.CANCEL_TRANSFER
50 ? 'cancel this transfer'
51 : 'perform this transaction';
53const signTransaction = async config => {
54 let {
55 wallet,
56 walletType,
57 walletHdPath,
58 networkType,
59 txn,
60 setStx,
61 nonce,
62 chainId,
63 gasPrice,
64 gasLimit,
65 } = config;
67 nonce = toHex(nonce);
68 chainId = toHex(chainId);
69 gasPrice = toHex(toWei(gasPrice, 'gwei'));
70 gasLimit = toHex(gasLimit);
72 const txParams = { nonce, chainId, gasPrice, gasLimit };
74 // NB (jtobin)
75 //
76 // Ledger does not seem to handle EIP-155 automatically. When using a Ledger,
77 // if the block number is at least FORK_BLKNUM = 2675000, one needs to
78 // pre-set the ECDSA signature parameters with r = 0, s = 0, and v = chainId
79 // prior to signing.
80 //
81 // The easiest way to handle this is to just branch on the network, since
82 // mainnet and Ropsten have obviously passed FORK_BLKNUM. This is somewhat
83 // awkward when dealing with offline transactions, since we might want to
84 // test them on a local network as well.
85 //
86 // The best thing to do is probably to add an 'advanced' tab to offline
87 // transaction generation where one can disable the defaulted-on EIP-155
88 // settings in this case. This is pretty low-priority, but is a
89 // comprehensive solution.
90 //
91 // See:
92 //
93 // See https://github.com/LedgerHQ/ledgerjs/issues/43#issuecomment-366984725
94 //
95 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md
97 const eip155Params = {
98 r: '0x00',
99 s: '0x00',
100 v: chainId,
101 };
103 const defaultEip155Networks = [
104 NETWORK_TYPES.MAINNET,
105 NETWORK_TYPES.ROPSTEN,
106 NETWORK_TYPES.OFFLINE,
107 ];
109 const needEip155Params =
110 walletType === WALLET_TYPES.LEDGER &&
111 defaultEip155Networks.includes(networkType);
113 const signingParams = needEip155Params
114 ? Object.assign(txParams, eip155Params)
115 : txParams;
117 const wal = wallet.matchWith({
118 Just: w => w.value,
119 Nothing: () => {
120 throw BRIDGE_ERROR.MISSING_WALLET;
121 },
122 });
124 const sec = wal.privateKey;
126 const utx = txn.matchWith({
127 Just: tx => Object.assign(tx.value, signingParams),
128 Nothing: () => {
129 throw BRIDGE_ERROR.MISSING_TXN;
130 },
131 });
133 const stx = new Tx(utx);
135 if (walletType === WALLET_TYPES.LEDGER) {
136 await ledgerSignTransaction(stx, walletHdPath);
137 } else if (walletType === WALLET_TYPES.TREZOR) {
138 await trezorSignTransaction(stx, walletHdPath);
139 } else {
140 stx.sign(sec);
141 }
143 setStx(Just(stx));
144 return stx;
145};
147const sendSignedTransaction = (web3, stx, doubtNonceError) => {
148 const rawTx = hexify(stx.serialize());
150 return new Promise(async (resolve, reject) => {
151 web3.eth
152 .sendSignedTransaction(rawTx)
153 .on('transactionHash', hash => {
154 resolve(hash);
155 })
156 .on('error', err => {
157 // if there's a nonce error, but we used the gas tank, it's likely
158 // that it's because the tank already submitted our transaction.
159 // we just wait for first confirmation here.
160 console.error(err);
161 const isKnownError = (err.message || '').includes(
162 'known transaction: '
163 );
164 const isNonceError = (err.message || '').includes(
165 "the tx doesn't have the correct nonce."
166 );
167 if (isKnownError || (doubtNonceError && isNonceError)) {
168 console.log(
169 'tx send error likely from gas tank submission, ignoring'
170 );
171 const txHash = web3.utils.keccak256(rawTx);
172 resolve(txHash);
173 } else {
174 reject(err.message || 'Transaction sending failed!');
175 }
176 });
177 });
178};
180// returns a Promise<bool>, where the bool indicates tx success/failure
181const waitForTransactionConfirm = (web3, txHash) => {
182 return retry(async (bail, n) => {
183 const receipt = await web3.eth.getTransactionReceipt(txHash);
184 let confirmed = receipt !== null;
185 if (confirmed) return receipt.status === true;
186 else throw new Error('retrying');
187 }, RETRY_OPTIONS);
188};
190const sendAndAwaitAll = async (web3, stxs, doubtNonceError) => {
191 await Promise.all(
192 stxs.map(tx => {
193 return new Promise(async (resolve, reject) => {
194 const txHash = await sendSignedTransaction(web3, tx, doubtNonceError);
195 await waitForTransactionConfirm(web3, txHash);
196 resolve();
197 });
198 })
199 );
200};
202const hexify = val => addHexPrefix(val.toString('hex'));
204const renderSignedTx = stx => ({
205 messageHash: hexify(stx.hash()),
206 v: hexify(stx.v),
207 s: hexify(stx.s),
208 r: hexify(stx.r),
209 rawTransaction: hexify(stx.serialize()),
210});
212const getTxnInfo = async (web3, addr) => {
213 let nonce = await web3.eth.getTransactionCount(addr);
214 let chainId = await web3.eth.net.getId();
215 let gasPrice = await web3.eth.getGasPrice();
216 return {
217 nonce: nonce,
218 chainId: chainId,
219 gasPrice: fromWei(gasPrice, 'gwei'),
220 };
221};
223const canDecodePatp = p => {
224 try {
225 ob.patp2dec(p);
226 return true;
227 } catch (_) {
228 return false;
229 }
230};
232export {
233 RETRY_OPTIONS,
234 signTransaction,
235 sendSignedTransaction,
236 waitForTransactionConfirm,
237 sendAndAwaitAll,
238 TXN_PURPOSE,
239 getTxnInfo,
240 renderTxnPurpose,
241 hexify,
242 renderSignedTx,
243 toHex,
244 toWei,
245 fromWei,
246 canDecodePatp,
247};