@@ -235,26 +235,26 @@ impl Request {
235
235
name. clone ( )
236
236
} else {
237
237
return Err ( Error :: new (
238
- ErrorKind :: Other ,
239
- "self. forward_request.domain missing 'name' field" ,
238
+ ErrorKind :: InvalidInput ,
239
+ "forward_request.domain missing 'name' field" ,
240
240
) ) ;
241
241
} ;
242
242
243
243
let domain_version = if let Some ( version) = & self . forward_request . domain . version {
244
244
version. clone ( )
245
245
} else {
246
246
return Err ( Error :: new (
247
- ErrorKind :: Other ,
248
- "self. forward_request.domain missing 'version' field" ,
247
+ ErrorKind :: InvalidInput ,
248
+ "forward_request.domain missing 'version' field" ,
249
249
) ) ;
250
250
} ;
251
251
252
252
let domain_chain_id = if let Some ( chain_id) = & self . forward_request . domain . chain_id {
253
253
chain_id
254
254
} else {
255
255
return Err ( Error :: new (
256
- ErrorKind :: Other ,
257
- "self. forward_request.domain missing 'chain_id' field" ,
256
+ ErrorKind :: InvalidInput ,
257
+ "forward_request.domain missing 'chain_id' field" ,
258
258
) ) ;
259
259
} ;
260
260
@@ -263,144 +263,210 @@ impl Request {
263
263
verifying_contract. clone ( )
264
264
} else {
265
265
return Err ( Error :: new (
266
- ErrorKind :: Other ,
267
- "self. forward_request.domain missing 'verifying_contract' field" ,
266
+ ErrorKind :: InvalidInput ,
267
+ "forward_request.domain missing 'verifying_contract' field" ,
268
268
) ) ;
269
269
} ;
270
270
271
271
let from = if let Some ( from) = self . forward_request . message . get ( "from" ) {
272
272
if let Some ( v) = from. as_str ( ) {
273
- H160 :: from_str ( v) . unwrap ( )
273
+ H160 :: from_str ( v) . map_err ( |e| {
274
+ Error :: new (
275
+ ErrorKind :: InvalidInput ,
276
+ format ! (
277
+ "forward_request.message.from[{v}] H160::from_str parse failed {:?}" ,
278
+ e
279
+ ) ,
280
+ )
281
+ } ) ?
274
282
} else {
275
283
return Err ( Error :: new (
276
- ErrorKind :: Other ,
277
- "self. forward_request.message expected type 'from'" ,
284
+ ErrorKind :: InvalidInput ,
285
+ "forward_request.message expected type 'from'" ,
278
286
) ) ;
279
287
}
280
288
} else {
281
289
return Err ( Error :: new (
282
- ErrorKind :: Other ,
283
- "self. forward_request.message missing 'from' field" ,
290
+ ErrorKind :: InvalidInput ,
291
+ "forward_request.message missing 'from' field" ,
284
292
) ) ;
285
293
} ;
286
294
287
295
let to = if let Some ( to) = self . forward_request . message . get ( "to" ) {
288
296
if let Some ( v) = to. as_str ( ) {
289
- H160 :: from_str ( v) . unwrap ( )
297
+ H160 :: from_str ( v) . map_err ( |e| {
298
+ Error :: new (
299
+ ErrorKind :: InvalidInput ,
300
+ format ! (
301
+ "forward_request.message.to[{v}] H160::from_str parse failed {:?}" ,
302
+ e
303
+ ) ,
304
+ )
305
+ } ) ?
290
306
} else {
291
307
return Err ( Error :: new (
292
- ErrorKind :: Other ,
293
- "self. forward_request.message expected type 'to'" ,
308
+ ErrorKind :: InvalidInput ,
309
+ "forward_request.message expected type 'to'" ,
294
310
) ) ;
295
311
}
296
312
} else {
297
313
return Err ( Error :: new (
298
- ErrorKind :: Other ,
299
- "self. forward_request.message missing 'to' field" ,
314
+ ErrorKind :: InvalidInput ,
315
+ "forward_request.message missing 'to' field" ,
300
316
) ) ;
301
317
} ;
302
318
303
319
let value = if let Some ( value) = self . forward_request . message . get ( "value" ) {
304
320
if let Some ( v) = value. as_str ( ) {
305
321
if v. starts_with ( "0x" ) {
306
- U256 :: from_str_radix ( v, 16 ) . unwrap ( )
322
+ U256 :: from_str_radix ( v, 16 ) . map_err ( |e| {
323
+ Error :: new (
324
+ ErrorKind :: InvalidInput ,
325
+ format ! ( "forward_request.message.value[{v}] U256::from_str_radix parse failed {:?}" , e) ,
326
+ )
327
+ } ) ?
307
328
} else {
308
- U256 :: from_str ( v) . unwrap ( )
329
+ U256 :: from_str ( v) . map_err ( |e| {
330
+ Error :: new (
331
+ ErrorKind :: InvalidInput ,
332
+ format ! ( "forward_request.message.value[{v}] U256::from_str parse failed {:?}" , e) ,
333
+ )
334
+ } ) ?
309
335
}
310
336
} else {
311
337
return Err ( Error :: new (
312
- ErrorKind :: Other ,
313
- "self. forward_request.message expected type 'value'" ,
338
+ ErrorKind :: InvalidInput ,
339
+ "forward_request.message expected type 'value'" ,
314
340
) ) ;
315
341
}
316
342
} else {
317
343
return Err ( Error :: new (
318
- ErrorKind :: Other ,
319
- "self. forward_request.message missing 'value' field" ,
344
+ ErrorKind :: InvalidInput ,
345
+ "forward_request.message missing 'value' field" ,
320
346
) ) ;
321
347
} ;
322
348
323
349
let gas = if let Some ( gas) = self . forward_request . message . get ( "gas" ) {
324
350
if let Some ( v) = gas. as_str ( ) {
325
351
if v. starts_with ( "0x" ) {
326
- U256 :: from_str_radix ( v, 16 ) . unwrap ( )
352
+ U256 :: from_str_radix ( v, 16 ) . map_err ( |e| {
353
+ Error :: new (
354
+ ErrorKind :: InvalidInput ,
355
+ format ! ( "forward_request.message.gas[{v}] U256::from_str_radix parse failed {:?}" , e) ,
356
+ )
357
+ } ) ?
327
358
} else {
328
- U256 :: from_str ( v) . unwrap ( )
359
+ U256 :: from_str ( v) . map_err ( |e| {
360
+ Error :: new (
361
+ ErrorKind :: InvalidInput ,
362
+ format ! (
363
+ "forward_request.message.gas[{v}] U256::from_str parse failed {:?}" ,
364
+ e
365
+ ) ,
366
+ )
367
+ } ) ?
329
368
}
330
369
} else {
331
370
return Err ( Error :: new (
332
- ErrorKind :: Other ,
333
- "self. forward_request.message expected type 'gas'" ,
371
+ ErrorKind :: InvalidInput ,
372
+ "forward_request.message expected type 'gas'" ,
334
373
) ) ;
335
374
}
336
375
} else {
337
376
return Err ( Error :: new (
338
- ErrorKind :: Other ,
339
- "self. forward_request.message missing 'gas' field" ,
377
+ ErrorKind :: InvalidInput ,
378
+ "forward_request.message missing 'gas' field" ,
340
379
) ) ;
341
380
} ;
342
381
343
382
let nonce = if let Some ( nonce) = self . forward_request . message . get ( "nonce" ) {
344
383
if let Some ( v) = nonce. as_str ( ) {
345
384
if v. starts_with ( "0x" ) {
346
- U256 :: from_str_radix ( v, 16 ) . unwrap ( )
385
+ U256 :: from_str_radix ( v, 16 ) . map_err ( |e| {
386
+ Error :: new (
387
+ ErrorKind :: InvalidInput ,
388
+ format ! ( "forward_request.message.nonce[{v}] U256::from_str_radix parse failed {:?}" , e) ,
389
+ )
390
+ } ) ?
347
391
} else {
348
- U256 :: from_str ( v) . unwrap ( )
392
+ U256 :: from_str ( v) . map_err ( |e| {
393
+ Error :: new (
394
+ ErrorKind :: InvalidInput ,
395
+ format ! ( "forward_request.message.nonce[{v}] U256::from_str parse failed {:?}" , e) ,
396
+ )
397
+ } ) ?
349
398
}
350
399
} else {
351
400
return Err ( Error :: new (
352
- ErrorKind :: Other ,
353
- "self. forward_request.message expected type 'nonce'" ,
401
+ ErrorKind :: InvalidInput ,
402
+ "forward_request.message expected type 'nonce'" ,
354
403
) ) ;
355
404
}
356
405
} else {
357
406
return Err ( Error :: new (
358
- ErrorKind :: Other ,
359
- "self. forward_request.message missing 'nonce' field" ,
407
+ ErrorKind :: InvalidInput ,
408
+ "forward_request.message missing 'nonce' field" ,
360
409
) ) ;
361
410
} ;
362
411
363
412
let data = if let Some ( data) = self . forward_request . message . get ( "data" ) {
364
413
if let Some ( v) = data. as_str ( ) {
365
414
hex:: decode ( v. trim_start_matches ( "0x" ) ) . map_err ( |e| {
366
415
Error :: new (
367
- ErrorKind :: Other ,
416
+ ErrorKind :: InvalidInput ,
368
417
format ! ( "failed hex::decode on 'data' field '{}'" , e) ,
369
418
)
370
419
} ) ?
371
420
} else {
372
421
return Err ( Error :: new (
373
- ErrorKind :: Other ,
374
- "self. forward_request.message expected type 'data'" ,
422
+ ErrorKind :: InvalidInput ,
423
+ "forward_request.message expected type 'data'" ,
375
424
) ) ;
376
425
}
377
426
} else {
378
427
return Err ( Error :: new (
379
- ErrorKind :: Other ,
380
- "self. forward_request.message missing 'data' field" ,
428
+ ErrorKind :: InvalidInput ,
429
+ "forward_request.message missing 'data' field" ,
381
430
) ) ;
382
431
} ;
383
432
384
- let valid_until_time =
385
- if let Some ( valid_until_time) = self . forward_request . message . get ( "validUntilTime" ) {
386
- if let Some ( v) = valid_until_time. as_str ( ) {
387
- if v. starts_with ( "0x" ) {
388
- U256 :: from_str_radix ( v, 16 ) . unwrap ( )
389
- } else {
390
- U256 :: from_str ( v) . unwrap ( )
391
- }
433
+ let valid_until_time = if let Some ( valid_until_time) =
434
+ self . forward_request . message . get ( "validUntilTime" )
435
+ {
436
+ if let Some ( v) = valid_until_time. as_str ( ) {
437
+ if v. starts_with ( "0x" ) {
438
+ U256 :: from_str_radix ( v, 16 ) . map_err ( |e| {
439
+ Error :: new (
440
+ ErrorKind :: InvalidInput ,
441
+ format ! (
442
+ "forward_request.message.validUntilTime[{v}] U256::from_str_radix parse failed {:?}" ,
443
+ e
444
+ ) ,
445
+ )
446
+ } ) ?
392
447
} else {
393
- return Err ( Error :: new (
394
- ErrorKind :: Other ,
395
- "self.forward_request.message expected type 'validUntilTime'" ,
396
- ) ) ;
448
+ U256 :: from_str ( v) . map_err ( |e| {
449
+ Error :: new (
450
+ ErrorKind :: InvalidInput ,
451
+ format ! (
452
+ "forward_request.message.validUntilTime[{v}] U256::from_str parse failed {:?}" ,
453
+ e
454
+ ) ,
455
+ )
456
+ } ) ?
397
457
}
398
458
} else {
399
459
return Err ( Error :: new (
400
- ErrorKind :: Other ,
401
- "self. forward_request.message missing 'validUntilTime' field " ,
460
+ ErrorKind :: InvalidInput ,
461
+ "forward_request.message expected type 'validUntilTime'" ,
402
462
) ) ;
403
- } ;
463
+ }
464
+ } else {
465
+ return Err ( Error :: new (
466
+ ErrorKind :: InvalidInput ,
467
+ "forward_request.message missing 'validUntilTime' field" ,
468
+ ) ) ;
469
+ } ;
404
470
405
471
Ok ( super :: Tx :: new ( )
406
472
. domain_name ( domain_name)
0 commit comments