difftreelog
refac: rename address -> Address
in: master
14 files changed
crates/evm-coder/procedural/src/to_log.rsdiffbeforeafterboth--- a/crates/evm-coder/procedural/src/to_log.rs
+++ b/crates/evm-coder/procedural/src/to_log.rs
@@ -231,7 +231,7 @@
#[automatically_derived]
impl ::evm_coder::events::ToLog for #name {
- fn to_log(&self, contract: address) -> ::ethereum::Log {
+ fn to_log(&self, contract: Address) -> ::ethereum::Log {
use ::evm_coder::events::ToTopic;
use ::evm_coder::abi::AbiWrite;
let mut writer = ::evm_coder::abi::AbiWriter::new();
crates/evm-coder/src/abi/test.rsdiffbeforeafterboth1use crate::{2 abi::{AbiRead, AbiWrite},3 types::*,4};56use super::{AbiReader, AbiWriter};7use hex_literal::hex;8use primitive_types::{H160, U256};910fn test_impl<T>(function_identifier: u32, decoded_data: T, encoded_data: &[u8])11where12 T: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,13{14 let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();15 assert_eq!(call, u32::to_be_bytes(function_identifier));16 let data = <T>::abi_read(&mut decoder).unwrap();17 assert_eq!(data, decoded_data);1819 let mut writer = AbiWriter::new_call(function_identifier);20 decoded_data.abi_write(&mut writer);21 let ed = writer.finish();22 similar_asserts::assert_eq!(encoded_data, ed.as_slice());23}2425macro_rules! test_impl_uint {26 ($type:ident) => {27 test_impl::<$type>(28 0xdeadbeef,29 255 as $type,30 &hex!(31 "32 deadbeef33 00000000000000000000000000000000000000000000000000000000000000ff34 "35 ),36 );37 };38}3940#[test]41fn encode_decode_uint8() {42 test_impl_uint!(u8);43}4445#[test]46fn encode_decode_uint32() {47 test_impl_uint!(u32);48}4950#[test]51fn encode_decode_uint128() {52 test_impl_uint!(u128);53}5455#[test]56fn encode_decode_uint256() {57 test_impl::<U256>(58 0xdeadbeef,59 U256([255, 0, 0, 0]),60 &hex!(61 "62 deadbeef63 00000000000000000000000000000000000000000000000000000000000000ff64 "65 ),66 );67}6869#[test]70fn encode_decode_string() {71 test_impl::<String>(72 0xdeadbeef,73 "some string".to_string(),74 &hex!(75 "76 deadbeef77 000000000000000000000000000000000000000000000000000000000000002078 000000000000000000000000000000000000000000000000000000000000000b79 736f6d6520737472696e6700000000000000000000000000000000000000000080 "81 ),82 );83}8485#[test]86fn encode_decode_tuple_string() {87 test_impl::<(String,)>(88 0xdeadbeef,89 ("some string".to_string(),),90 &hex!(91 "92 deadbeef93 000000000000000000000000000000000000000000000000000000000000002094 000000000000000000000000000000000000000000000000000000000000002095 000000000000000000000000000000000000000000000000000000000000000b96 736f6d6520737472696e6700000000000000000000000000000000000000000097 "98 ),99 );100}101102#[test]103fn encode_decode_vec_tuple_address_uint256() {104 test_impl::<Vec<(address, U256)>>(105 0x1ACF2D55,106 vec![107 (108 H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),109 U256([10, 0, 0, 0]),110 ),111 (112 H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),113 U256([20, 0, 0, 0]),114 ),115 (116 H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),117 U256([30, 0, 0, 0]),118 ),119 ],120 &hex!(121 "122 1ACF2D55123 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]124 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]125126 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address127 000000000000000000000000000000000000000000000000000000000000000A // uint256128129 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address130 0000000000000000000000000000000000000000000000000000000000000014 // uint256131132 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address133 000000000000000000000000000000000000000000000000000000000000001E // uint256134 "135 )136 );137}138139#[test]140fn encode_decode_vec_tuple_uint256_string() {141 test_impl::<Vec<(U256, string)>>(142 0xdeadbeef,143 vec![144 (1.into(), "Test URI 0".to_string()),145 (11.into(), "Test URI 1".to_string()),146 (12.into(), "Test URI 2".to_string()),147 ],148 &hex!(149 "150 deadbeef151 0000000000000000000000000000000000000000000000000000000000000020 // offset of (uint256, string)[]152 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]153154 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem155 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem156 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem157158 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60159 0000000000000000000000000000000000000000000000000000000000000040 // offset of string160 000000000000000000000000000000000000000000000000000000000000000a // size of string161 5465737420555249203000000000000000000000000000000000000000000000 // string162163 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0164 0000000000000000000000000000000000000000000000000000000000000040 // offset of string165 000000000000000000000000000000000000000000000000000000000000000a // size of string166 5465737420555249203100000000000000000000000000000000000000000000 // string167168 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160169 0000000000000000000000000000000000000000000000000000000000000040 // offset of string170 000000000000000000000000000000000000000000000000000000000000000a // size of string171 5465737420555249203200000000000000000000000000000000000000000000 // string172 "173 )174 );175}176177#[test]178fn dynamic_after_static() {179 let mut encoder = AbiWriter::new();180 encoder.bool(&true);181 encoder.string("test");182 let encoded = encoder.finish();183184 let mut encoder = AbiWriter::new();185 encoder.bool(&true);186 // Offset to subresult187 encoder.uint32(&(32 * 2));188 // Len of "test"189 encoder.uint32(&4);190 encoder.write_padright(&[b't', b'e', b's', b't']);191 let alternative_encoded = encoder.finish();192193 assert_eq!(encoded, alternative_encoded);194195 let mut decoder = AbiReader::new(&encoded);196 assert!(decoder.bool().unwrap());197 assert_eq!(decoder.string().unwrap(), "test");198}199200#[test]201fn mint_sample() {202 let (call, mut decoder) = AbiReader::new_call(&hex!(203 "204 50bb4e7f205 000000000000000000000000ad2c0954693c2b5404b7e50967d3481bea432374206 0000000000000000000000000000000000000000000000000000000000000001207 0000000000000000000000000000000000000000000000000000000000000060208 0000000000000000000000000000000000000000000000000000000000000008209 5465737420555249000000000000000000000000000000000000000000000000210 "211 ))212 .unwrap();213 assert_eq!(call, u32::to_be_bytes(0x50bb4e7f));214 assert_eq!(215 format!("{:?}", decoder.address().unwrap()),216 "0xad2c0954693c2b5404b7e50967d3481bea432374"217 );218 assert_eq!(decoder.uint32().unwrap(), 1);219 assert_eq!(decoder.string().unwrap(), "Test URI");220}221222#[test]223fn parse_vec_with_dynamic_type() {224 let decoded_data = (225 0x36543006,226 vec![227 (1.into(), "Test URI 0".to_string()),228 (11.into(), "Test URI 1".to_string()),229 (12.into(), "Test URI 2".to_string()),230 ],231 );232233 let encoded_data = &hex!(234 "235 36543006236 00000000000000000000000053744e6da587ba10b32a2554d2efdcd985bc27a3 // address237 0000000000000000000000000000000000000000000000000000000000000040 // offset of (uint256, string)[]238 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]239240 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem241 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem242 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem243244 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60245 0000000000000000000000000000000000000000000000000000000000000040 // offset of string246 000000000000000000000000000000000000000000000000000000000000000a // size of string247 5465737420555249203000000000000000000000000000000000000000000000 // string248249 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0250 0000000000000000000000000000000000000000000000000000000000000040 // offset of string251 000000000000000000000000000000000000000000000000000000000000000a // size of string252 5465737420555249203100000000000000000000000000000000000000000000 // string253254 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160255 0000000000000000000000000000000000000000000000000000000000000040 // offset of string256 000000000000000000000000000000000000000000000000000000000000000a // size of string257 5465737420555249203200000000000000000000000000000000000000000000 // string258 "259 );260261 let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();262 assert_eq!(call, u32::to_be_bytes(decoded_data.0));263 let address = decoder.address().unwrap();264 let data = <Vec<(U256, string)>>::abi_read(&mut decoder).unwrap();265 assert_eq!(data, decoded_data.1);266267 let mut writer = AbiWriter::new_call(decoded_data.0);268 address.abi_write(&mut writer);269 decoded_data.1.abi_write(&mut writer);270 let ed = writer.finish();271 similar_asserts::assert_eq!(encoded_data, ed.as_slice());272}273274#[test]275fn encode_decode_vec_tuple_string_bytes() {276 test_impl::<Vec<(string, bytes)>>(277 0xdeadbeef,278 vec![279 (280 "Test URI 0".to_string(),281 bytes(vec![282 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,283 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,284 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,285 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,286 ]),287 ),288 (289 "Test URI 1".to_string(),290 bytes(vec![291 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,292 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,293 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,294 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,295 ]),296 ),297 ("Test URI 2".to_string(), bytes(vec![0x33, 0x33])),298 ],299 &hex!(300 "301 deadbeef302 0000000000000000000000000000000000000000000000000000000000000020303 0000000000000000000000000000000000000000000000000000000000000003304305 0000000000000000000000000000000000000000000000000000000000000060306 0000000000000000000000000000000000000000000000000000000000000140307 0000000000000000000000000000000000000000000000000000000000000220308309 0000000000000000000000000000000000000000000000000000000000000040310 0000000000000000000000000000000000000000000000000000000000000080311 000000000000000000000000000000000000000000000000000000000000000a312 5465737420555249203000000000000000000000000000000000000000000000313 0000000000000000000000000000000000000000000000000000000000000030314 1111111111111111111111111111111111111111111111111111111111111111315 1111111111111111111111111111111100000000000000000000000000000000316317 0000000000000000000000000000000000000000000000000000000000000040318 0000000000000000000000000000000000000000000000000000000000000080319 000000000000000000000000000000000000000000000000000000000000000a320 5465737420555249203100000000000000000000000000000000000000000000321 000000000000000000000000000000000000000000000000000000000000002f322 2222222222222222222222222222222222222222222222222222222222222222323 2222222222222222222222222222220000000000000000000000000000000000324325 0000000000000000000000000000000000000000000000000000000000000040326 0000000000000000000000000000000000000000000000000000000000000080327 000000000000000000000000000000000000000000000000000000000000000a328 5465737420555249203200000000000000000000000000000000000000000000329 0000000000000000000000000000000000000000000000000000000000000002330 3333000000000000000000000000000000000000000000000000000000000000331 "332 ),333 );334}335336#[test]337// #[ignore = "reason"]338fn encode_decode_tuple0_tuple1_uint8_tuple1_string_bytes_tuple1_uint8_bytes() {339 let int = 0xff;340 let by = bytes(vec![0x11, 0x22, 0x33]);341 let string = "some string".to_string();342343 test_impl::<((u8,), (String, bytes), (u8, bytes))>(344 0xdeadbeef,345 ((int,), (string.clone(), by.clone()), (int, by)),346 &hex!(347 "348 deadbeef349 0000000000000000000000000000000000000000000000000000000000000020350 00000000000000000000000000000000000000000000000000000000000000ff351 0000000000000000000000000000000000000000000000000000000000000060352 0000000000000000000000000000000000000000000000000000000000000120353 0000000000000000000000000000000000000000000000000000000000000040354 0000000000000000000000000000000000000000000000000000000000000080355 000000000000000000000000000000000000000000000000000000000000000b356 736f6d6520737472696e67000000000000000000000000000000000000000000357 0000000000000000000000000000000000000000000000000000000000000003358 1122330000000000000000000000000000000000000000000000000000000000359 00000000000000000000000000000000000000000000000000000000000000ff360 0000000000000000000000000000000000000000000000000000000000000040361 0000000000000000000000000000000000000000000000000000000000000003362 1122330000000000000000000000000000000000000000000000000000000000363 "364 ),365 );366}367368#[test]369fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8_uint8_tuple1_uint8_uint8() {370 test_impl::<((u8,), (u8, u8), (u8, u8))>(371 0xdeadbeef,372 ((43,), (44, 45), (46, 47)),373 &hex!(374 "375 deadbeef376 000000000000000000000000000000000000000000000000000000000000002b377 000000000000000000000000000000000000000000000000000000000000002c378 000000000000000000000000000000000000000000000000000000000000002d379 000000000000000000000000000000000000000000000000000000000000002e380 000000000000000000000000000000000000000000000000000000000000002f381 "382 ),383 );384}385386#[test]387fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8() {388 test_impl::<((u8,), (u8,))>(389 0xdeadbeef,390 ((43,), (44,)),391 &hex!(392 "393 deadbeef394 000000000000000000000000000000000000000000000000000000000000002b395 000000000000000000000000000000000000000000000000000000000000002c396 "397 ),398 );399}400401#[test]402fn encode_decode_tuple0_tuple1_uint8_uint8() {403 test_impl::<((u8, u8),)>(404 0xdeadbeef,405 ((43, 44),),406 &hex!(407 "408 deadbeef409 000000000000000000000000000000000000000000000000000000000000002b410 000000000000000000000000000000000000000000000000000000000000002c411 "412 ),413 );414}415416#[test]417fn encode_decode_tuple_uint8_uint8() {418 test_impl::<(u8, u8)>(419 0xdeadbeef,420 (43, 44),421 &hex!(422 "423 deadbeef424 000000000000000000000000000000000000000000000000000000000000002b425 000000000000000000000000000000000000000000000000000000000000002c426 "427 ),428 );429}430431#[test]432fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {433 test_impl::<((u8, u8), (u8, u8), u8)>(434 0xdeadbeef,435 ((10, 11), (12, 13), 14),436 &hex!(437 "438 deadbeef439 000000000000000000000000000000000000000000000000000000000000000a440 000000000000000000000000000000000000000000000000000000000000000b441 000000000000000000000000000000000000000000000000000000000000000c442 000000000000000000000000000000000000000000000000000000000000000d443 000000000000000000000000000000000000000000000000000000000000000e444 "445 ),446 );447}448449#[test]450fn encode_decode_tuple0_tuple1_string() {451 test_impl::<((String,),)>(452 0xdeadbeef,453 (("some string".to_string(),),),454 &hex!(455 "456 deadbeef457 0000000000000000000000000000000000000000000000000000000000000020458 0000000000000000000000000000000000000000000000000000000000000020459 0000000000000000000000000000000000000000000000000000000000000020460 000000000000000000000000000000000000000000000000000000000000000b461 736f6d6520737472696e67000000000000000000000000000000000000000000462 "463 ),464 );465}466467#[test]468fn encode_decode_tuple0_tuple1_uint8_string() {469 test_impl::<((u8, String),)>(470 0xdeadbeef,471 ((0xff, "some string".to_string()),),472 &hex!(473 "474 deadbeef475 0000000000000000000000000000000000000000000000000000000000000020476 0000000000000000000000000000000000000000000000000000000000000020477 00000000000000000000000000000000000000000000000000000000000000ff478 0000000000000000000000000000000000000000000000000000000000000040479 000000000000000000000000000000000000000000000000000000000000000b480 736f6d6520737472696e67000000000000000000000000000000000000000000481 "482 ),483 );484}485486#[test]487fn encode_decode_tuple0_tuple1_string_bytes() {488 test_impl::<((String, bytes),)>(489 0xdeadbeef,490 (("some string".to_string(), bytes(vec![1, 2, 3])),),491 &hex!(492 "493 deadbeef494 0000000000000000000000000000000000000000000000000000000000000020495 0000000000000000000000000000000000000000000000000000000000000020496 0000000000000000000000000000000000000000000000000000000000000040497 0000000000000000000000000000000000000000000000000000000000000080498 000000000000000000000000000000000000000000000000000000000000000b499 736f6d6520737472696e67000000000000000000000000000000000000000000500 0000000000000000000000000000000000000000000000000000000000000003501 0102030000000000000000000000000000000000000000000000000000000000502 "503 ),504 );505}506507#[test]508fn encode_decode_tuple0_tuple1_uint8_tuple1_string() {509 test_impl::<((u8,), (String,))>(510 0xdeadbeef,511 ((0xff,), ("some string".to_string(),)),512 &hex!(513 "514 deadbeef515 0000000000000000000000000000000000000000000000000000000000000020516 00000000000000000000000000000000000000000000000000000000000000ff517 0000000000000000000000000000000000000000000000000000000000000040518 0000000000000000000000000000000000000000000000000000000000000020519 000000000000000000000000000000000000000000000000000000000000000b520 736f6d6520737472696e67000000000000000000000000000000000000000000521 "522 ),523 );524}525526#[test]527fn parse_multiple_params() {528 let encoded_data = hex!(529 "530 deadbeef531 000000000000000000000000000000000000000000000000000000000000000a532 000000000000000000000000000000000000000000000000000000000000000b533 "534 );535 let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();536 let p1 = <u8>::abi_read(&mut decoder).unwrap();537 let p2 = <u8>::abi_read(&mut decoder).unwrap();538 assert_eq!(p1, 0x0a);539 assert_eq!(p2, 0x0b);540}541542#[test]543fn encode_decode_option_uint8_some() {544 test_impl::<Option<u8>>(545 0xdeadbeef,546 Some(44),547 &hex!(548 "549 deadbeef550 0000000000000000000000000000000000000000000000000000000000000001551 000000000000000000000000000000000000000000000000000000000000002c552 "553 ),554 );555}556557#[test]558fn encode_decode_option_uint8_none() {559 test_impl::<Option<u8>>(560 0xdeadbeef,561 None,562 &hex!(563 "564 deadbeef565 0000000000000000000000000000000000000000000000000000000000000000566 0000000000000000000000000000000000000000000000000000000000000000567 "568 ),569 );570}571572#[test]573fn encode_decode_option_string_some() {574 test_impl::<Option<String>>(575 0xdeadbeef,576 Some("some string".to_string()),577 &hex!(578 "579 deadbeef580 0000000000000000000000000000000000000000000000000000000000000020581 0000000000000000000000000000000000000000000000000000000000000001582 0000000000000000000000000000000000000000000000000000000000000040583 000000000000000000000000000000000000000000000000000000000000000b584 736f6d6520737472696e67000000000000000000000000000000000000000000585 "586 ),587 );588}589590#[test]591fn encode_decode_option_string_none() {592 test_impl::<Option<String>>(593 0xdeadbeef,594 None,595 &hex!(596 "597 deadbeef598 0000000000000000000000000000000000000000000000000000000000000020599 0000000000000000000000000000000000000000000000000000000000000000600 0000000000000000000000000000000000000000000000000000000000000040601 0000000000000000000000000000000000000000000000000000000000000000602 "603 ),604 );605}1use crate::{2 abi::{AbiRead, AbiWrite},3 types::*,4};56use super::{AbiReader, AbiWriter};7use hex_literal::hex;8use primitive_types::{H160, U256};910fn test_impl<T>(function_identifier: u32, decoded_data: T, encoded_data: &[u8])11where12 T: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,13{14 let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();15 assert_eq!(call, u32::to_be_bytes(function_identifier));16 let data = <T>::abi_read(&mut decoder).unwrap();17 assert_eq!(data, decoded_data);1819 let mut writer = AbiWriter::new_call(function_identifier);20 decoded_data.abi_write(&mut writer);21 let ed = writer.finish();22 similar_asserts::assert_eq!(encoded_data, ed.as_slice());23}2425macro_rules! test_impl_uint {26 ($type:ident) => {27 test_impl::<$type>(28 0xdeadbeef,29 255 as $type,30 &hex!(31 "32 deadbeef33 00000000000000000000000000000000000000000000000000000000000000ff34 "35 ),36 );37 };38}3940#[test]41fn encode_decode_uint8() {42 test_impl_uint!(u8);43}4445#[test]46fn encode_decode_uint32() {47 test_impl_uint!(u32);48}4950#[test]51fn encode_decode_uint128() {52 test_impl_uint!(u128);53}5455#[test]56fn encode_decode_uint256() {57 test_impl::<U256>(58 0xdeadbeef,59 U256([255, 0, 0, 0]),60 &hex!(61 "62 deadbeef63 00000000000000000000000000000000000000000000000000000000000000ff64 "65 ),66 );67}6869#[test]70fn encode_decode_string() {71 test_impl::<String>(72 0xdeadbeef,73 "some string".to_string(),74 &hex!(75 "76 deadbeef77 000000000000000000000000000000000000000000000000000000000000002078 000000000000000000000000000000000000000000000000000000000000000b79 736f6d6520737472696e6700000000000000000000000000000000000000000080 "81 ),82 );83}8485#[test]86fn encode_decode_tuple_string() {87 test_impl::<(String,)>(88 0xdeadbeef,89 ("some string".to_string(),),90 &hex!(91 "92 deadbeef93 000000000000000000000000000000000000000000000000000000000000002094 000000000000000000000000000000000000000000000000000000000000002095 000000000000000000000000000000000000000000000000000000000000000b96 736f6d6520737472696e6700000000000000000000000000000000000000000097 "98 ),99 );100}101102#[test]103fn encode_decode_vec_tuple_address_uint256() {104 test_impl::<Vec<(Address, U256)>>(105 0x1ACF2D55,106 vec![107 (108 H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),109 U256([10, 0, 0, 0]),110 ),111 (112 H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),113 U256([20, 0, 0, 0]),114 ),115 (116 H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),117 U256([30, 0, 0, 0]),118 ),119 ],120 &hex!(121 "122 1ACF2D55123 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]124 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]125126 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address127 000000000000000000000000000000000000000000000000000000000000000A // uint256128129 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address130 0000000000000000000000000000000000000000000000000000000000000014 // uint256131132 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address133 000000000000000000000000000000000000000000000000000000000000001E // uint256134 "135 )136 );137}138139#[test]140fn encode_decode_vec_tuple_uint256_string() {141 test_impl::<Vec<(U256, string)>>(142 0xdeadbeef,143 vec![144 (1.into(), "Test URI 0".to_string()),145 (11.into(), "Test URI 1".to_string()),146 (12.into(), "Test URI 2".to_string()),147 ],148 &hex!(149 "150 deadbeef151 0000000000000000000000000000000000000000000000000000000000000020 // offset of (uint256, string)[]152 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]153154 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem155 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem156 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem157158 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60159 0000000000000000000000000000000000000000000000000000000000000040 // offset of string160 000000000000000000000000000000000000000000000000000000000000000a // size of string161 5465737420555249203000000000000000000000000000000000000000000000 // string162163 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0164 0000000000000000000000000000000000000000000000000000000000000040 // offset of string165 000000000000000000000000000000000000000000000000000000000000000a // size of string166 5465737420555249203100000000000000000000000000000000000000000000 // string167168 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160169 0000000000000000000000000000000000000000000000000000000000000040 // offset of string170 000000000000000000000000000000000000000000000000000000000000000a // size of string171 5465737420555249203200000000000000000000000000000000000000000000 // string172 "173 )174 );175}176177#[test]178fn dynamic_after_static() {179 let mut encoder = AbiWriter::new();180 encoder.bool(&true);181 encoder.string("test");182 let encoded = encoder.finish();183184 let mut encoder = AbiWriter::new();185 encoder.bool(&true);186 // Offset to subresult187 encoder.uint32(&(32 * 2));188 // Len of "test"189 encoder.uint32(&4);190 encoder.write_padright(&[b't', b'e', b's', b't']);191 let alternative_encoded = encoder.finish();192193 assert_eq!(encoded, alternative_encoded);194195 let mut decoder = AbiReader::new(&encoded);196 assert!(decoder.bool().unwrap());197 assert_eq!(decoder.string().unwrap(), "test");198}199200#[test]201fn mint_sample() {202 let (call, mut decoder) = AbiReader::new_call(&hex!(203 "204 50bb4e7f205 000000000000000000000000ad2c0954693c2b5404b7e50967d3481bea432374206 0000000000000000000000000000000000000000000000000000000000000001207 0000000000000000000000000000000000000000000000000000000000000060208 0000000000000000000000000000000000000000000000000000000000000008209 5465737420555249000000000000000000000000000000000000000000000000210 "211 ))212 .unwrap();213 assert_eq!(call, u32::to_be_bytes(0x50bb4e7f));214 assert_eq!(215 format!("{:?}", decoder.address().unwrap()),216 "0xad2c0954693c2b5404b7e50967d3481bea432374"217 );218 assert_eq!(decoder.uint32().unwrap(), 1);219 assert_eq!(decoder.string().unwrap(), "Test URI");220}221222#[test]223fn parse_vec_with_dynamic_type() {224 let decoded_data = (225 0x36543006,226 vec![227 (1.into(), "Test URI 0".to_string()),228 (11.into(), "Test URI 1".to_string()),229 (12.into(), "Test URI 2".to_string()),230 ],231 );232233 let encoded_data = &hex!(234 "235 36543006236 00000000000000000000000053744e6da587ba10b32a2554d2efdcd985bc27a3 // address237 0000000000000000000000000000000000000000000000000000000000000040 // offset of (uint256, string)[]238 0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]239240 0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem241 00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem242 0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem243244 0000000000000000000000000000000000000000000000000000000000000001 // first token id? #60245 0000000000000000000000000000000000000000000000000000000000000040 // offset of string246 000000000000000000000000000000000000000000000000000000000000000a // size of string247 5465737420555249203000000000000000000000000000000000000000000000 // string248249 000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11? #e0250 0000000000000000000000000000000000000000000000000000000000000040 // offset of string251 000000000000000000000000000000000000000000000000000000000000000a // size of string252 5465737420555249203100000000000000000000000000000000000000000000 // string253254 000000000000000000000000000000000000000000000000000000000000000c // third token id? Why ==12? #160255 0000000000000000000000000000000000000000000000000000000000000040 // offset of string256 000000000000000000000000000000000000000000000000000000000000000a // size of string257 5465737420555249203200000000000000000000000000000000000000000000 // string258 "259 );260261 let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();262 assert_eq!(call, u32::to_be_bytes(decoded_data.0));263 let address = decoder.address().unwrap();264 let data = <Vec<(U256, string)>>::abi_read(&mut decoder).unwrap();265 assert_eq!(data, decoded_data.1);266267 let mut writer = AbiWriter::new_call(decoded_data.0);268 address.abi_write(&mut writer);269 decoded_data.1.abi_write(&mut writer);270 let ed = writer.finish();271 similar_asserts::assert_eq!(encoded_data, ed.as_slice());272}273274#[test]275fn encode_decode_vec_tuple_string_bytes() {276 test_impl::<Vec<(string, bytes)>>(277 0xdeadbeef,278 vec![279 (280 "Test URI 0".to_string(),281 bytes(vec![282 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,283 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,284 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,285 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,286 ]),287 ),288 (289 "Test URI 1".to_string(),290 bytes(vec![291 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,292 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,293 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,294 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,295 ]),296 ),297 ("Test URI 2".to_string(), bytes(vec![0x33, 0x33])),298 ],299 &hex!(300 "301 deadbeef302 0000000000000000000000000000000000000000000000000000000000000020303 0000000000000000000000000000000000000000000000000000000000000003304305 0000000000000000000000000000000000000000000000000000000000000060306 0000000000000000000000000000000000000000000000000000000000000140307 0000000000000000000000000000000000000000000000000000000000000220308309 0000000000000000000000000000000000000000000000000000000000000040310 0000000000000000000000000000000000000000000000000000000000000080311 000000000000000000000000000000000000000000000000000000000000000a312 5465737420555249203000000000000000000000000000000000000000000000313 0000000000000000000000000000000000000000000000000000000000000030314 1111111111111111111111111111111111111111111111111111111111111111315 1111111111111111111111111111111100000000000000000000000000000000316317 0000000000000000000000000000000000000000000000000000000000000040318 0000000000000000000000000000000000000000000000000000000000000080319 000000000000000000000000000000000000000000000000000000000000000a320 5465737420555249203100000000000000000000000000000000000000000000321 000000000000000000000000000000000000000000000000000000000000002f322 2222222222222222222222222222222222222222222222222222222222222222323 2222222222222222222222222222220000000000000000000000000000000000324325 0000000000000000000000000000000000000000000000000000000000000040326 0000000000000000000000000000000000000000000000000000000000000080327 000000000000000000000000000000000000000000000000000000000000000a328 5465737420555249203200000000000000000000000000000000000000000000329 0000000000000000000000000000000000000000000000000000000000000002330 3333000000000000000000000000000000000000000000000000000000000000331 "332 ),333 );334}335336#[test]337// #[ignore = "reason"]338fn encode_decode_tuple0_tuple1_uint8_tuple1_string_bytes_tuple1_uint8_bytes() {339 let int = 0xff;340 let by = bytes(vec![0x11, 0x22, 0x33]);341 let string = "some string".to_string();342343 test_impl::<((u8,), (String, bytes), (u8, bytes))>(344 0xdeadbeef,345 ((int,), (string.clone(), by.clone()), (int, by)),346 &hex!(347 "348 deadbeef349 0000000000000000000000000000000000000000000000000000000000000020350 00000000000000000000000000000000000000000000000000000000000000ff351 0000000000000000000000000000000000000000000000000000000000000060352 0000000000000000000000000000000000000000000000000000000000000120353 0000000000000000000000000000000000000000000000000000000000000040354 0000000000000000000000000000000000000000000000000000000000000080355 000000000000000000000000000000000000000000000000000000000000000b356 736f6d6520737472696e67000000000000000000000000000000000000000000357 0000000000000000000000000000000000000000000000000000000000000003358 1122330000000000000000000000000000000000000000000000000000000000359 00000000000000000000000000000000000000000000000000000000000000ff360 0000000000000000000000000000000000000000000000000000000000000040361 0000000000000000000000000000000000000000000000000000000000000003362 1122330000000000000000000000000000000000000000000000000000000000363 "364 ),365 );366}367368#[test]369fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8_uint8_tuple1_uint8_uint8() {370 test_impl::<((u8,), (u8, u8), (u8, u8))>(371 0xdeadbeef,372 ((43,), (44, 45), (46, 47)),373 &hex!(374 "375 deadbeef376 000000000000000000000000000000000000000000000000000000000000002b377 000000000000000000000000000000000000000000000000000000000000002c378 000000000000000000000000000000000000000000000000000000000000002d379 000000000000000000000000000000000000000000000000000000000000002e380 000000000000000000000000000000000000000000000000000000000000002f381 "382 ),383 );384}385386#[test]387fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8() {388 test_impl::<((u8,), (u8,))>(389 0xdeadbeef,390 ((43,), (44,)),391 &hex!(392 "393 deadbeef394 000000000000000000000000000000000000000000000000000000000000002b395 000000000000000000000000000000000000000000000000000000000000002c396 "397 ),398 );399}400401#[test]402fn encode_decode_tuple0_tuple1_uint8_uint8() {403 test_impl::<((u8, u8),)>(404 0xdeadbeef,405 ((43, 44),),406 &hex!(407 "408 deadbeef409 000000000000000000000000000000000000000000000000000000000000002b410 000000000000000000000000000000000000000000000000000000000000002c411 "412 ),413 );414}415416#[test]417fn encode_decode_tuple_uint8_uint8() {418 test_impl::<(u8, u8)>(419 0xdeadbeef,420 (43, 44),421 &hex!(422 "423 deadbeef424 000000000000000000000000000000000000000000000000000000000000002b425 000000000000000000000000000000000000000000000000000000000000002c426 "427 ),428 );429}430431#[test]432fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {433 test_impl::<((u8, u8), (u8, u8), u8)>(434 0xdeadbeef,435 ((10, 11), (12, 13), 14),436 &hex!(437 "438 deadbeef439 000000000000000000000000000000000000000000000000000000000000000a440 000000000000000000000000000000000000000000000000000000000000000b441 000000000000000000000000000000000000000000000000000000000000000c442 000000000000000000000000000000000000000000000000000000000000000d443 000000000000000000000000000000000000000000000000000000000000000e444 "445 ),446 );447}448449#[test]450fn encode_decode_tuple0_tuple1_string() {451 test_impl::<((String,),)>(452 0xdeadbeef,453 (("some string".to_string(),),),454 &hex!(455 "456 deadbeef457 0000000000000000000000000000000000000000000000000000000000000020458 0000000000000000000000000000000000000000000000000000000000000020459 0000000000000000000000000000000000000000000000000000000000000020460 000000000000000000000000000000000000000000000000000000000000000b461 736f6d6520737472696e67000000000000000000000000000000000000000000462 "463 ),464 );465}466467#[test]468fn encode_decode_tuple0_tuple1_uint8_string() {469 test_impl::<((u8, String),)>(470 0xdeadbeef,471 ((0xff, "some string".to_string()),),472 &hex!(473 "474 deadbeef475 0000000000000000000000000000000000000000000000000000000000000020476 0000000000000000000000000000000000000000000000000000000000000020477 00000000000000000000000000000000000000000000000000000000000000ff478 0000000000000000000000000000000000000000000000000000000000000040479 000000000000000000000000000000000000000000000000000000000000000b480 736f6d6520737472696e67000000000000000000000000000000000000000000481 "482 ),483 );484}485486#[test]487fn encode_decode_tuple0_tuple1_string_bytes() {488 test_impl::<((String, bytes),)>(489 0xdeadbeef,490 (("some string".to_string(), bytes(vec![1, 2, 3])),),491 &hex!(492 "493 deadbeef494 0000000000000000000000000000000000000000000000000000000000000020495 0000000000000000000000000000000000000000000000000000000000000020496 0000000000000000000000000000000000000000000000000000000000000040497 0000000000000000000000000000000000000000000000000000000000000080498 000000000000000000000000000000000000000000000000000000000000000b499 736f6d6520737472696e67000000000000000000000000000000000000000000500 0000000000000000000000000000000000000000000000000000000000000003501 0102030000000000000000000000000000000000000000000000000000000000502 "503 ),504 );505}506507#[test]508fn encode_decode_tuple0_tuple1_uint8_tuple1_string() {509 test_impl::<((u8,), (String,))>(510 0xdeadbeef,511 ((0xff,), ("some string".to_string(),)),512 &hex!(513 "514 deadbeef515 0000000000000000000000000000000000000000000000000000000000000020516 00000000000000000000000000000000000000000000000000000000000000ff517 0000000000000000000000000000000000000000000000000000000000000040518 0000000000000000000000000000000000000000000000000000000000000020519 000000000000000000000000000000000000000000000000000000000000000b520 736f6d6520737472696e67000000000000000000000000000000000000000000521 "522 ),523 );524}525526#[test]527fn parse_multiple_params() {528 let encoded_data = hex!(529 "530 deadbeef531 000000000000000000000000000000000000000000000000000000000000000a532 000000000000000000000000000000000000000000000000000000000000000b533 "534 );535 let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();536 let p1 = <u8>::abi_read(&mut decoder).unwrap();537 let p2 = <u8>::abi_read(&mut decoder).unwrap();538 assert_eq!(p1, 0x0a);539 assert_eq!(p2, 0x0b);540}541542#[test]543fn encode_decode_option_uint8_some() {544 test_impl::<Option<u8>>(545 0xdeadbeef,546 Some(44),547 &hex!(548 "549 deadbeef550 0000000000000000000000000000000000000000000000000000000000000001551 000000000000000000000000000000000000000000000000000000000000002c552 "553 ),554 );555}556557#[test]558fn encode_decode_option_uint8_none() {559 test_impl::<Option<u8>>(560 0xdeadbeef,561 None,562 &hex!(563 "564 deadbeef565 0000000000000000000000000000000000000000000000000000000000000000566 0000000000000000000000000000000000000000000000000000000000000000567 "568 ),569 );570}571572#[test]573fn encode_decode_option_string_some() {574 test_impl::<Option<String>>(575 0xdeadbeef,576 Some("some string".to_string()),577 &hex!(578 "579 deadbeef580 0000000000000000000000000000000000000000000000000000000000000020581 0000000000000000000000000000000000000000000000000000000000000001582 0000000000000000000000000000000000000000000000000000000000000040583 000000000000000000000000000000000000000000000000000000000000000b584 736f6d6520737472696e67000000000000000000000000000000000000000000585 "586 ),587 );588}589590#[test]591fn encode_decode_option_string_none() {592 test_impl::<Option<String>>(593 0xdeadbeef,594 None,595 &hex!(596 "597 deadbeef598 0000000000000000000000000000000000000000000000000000000000000020599 0000000000000000000000000000000000000000000000000000000000000000600 0000000000000000000000000000000000000000000000000000000000000040601 0000000000000000000000000000000000000000000000000000000000000000602 "603 ),604 );605}crates/evm-coder/src/events.rsdiffbeforeafterboth--- a/crates/evm-coder/src/events.rs
+++ b/crates/evm-coder/src/events.rs
@@ -53,7 +53,7 @@
}
}
-impl ToTopic for address {
+impl ToTopic for Address {
fn to_topic(&self) -> H256 {
let mut out = [0u8; 32];
out[12..32].copy_from_slice(&self.0);
crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -131,7 +131,7 @@
use alloc::{vec::Vec};
use primitive_types::{U256, H160, H256};
- pub type address = H160;
+ pub type Address = H160;
pub type bytes4 = [u8; 4];
pub type topic = H256;
@@ -147,7 +147,7 @@
/// Makes function payable
pub type value = U256;
/// Makes function caller-sensitive
- pub type caller = address;
+ pub type caller = Address;
//#endregion
/// Ethereum typed call message, similar to solidity
crates/evm-coder/tests/log.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/log.rs
+++ b/crates/evm-coder/tests/log.rs
@@ -23,14 +23,14 @@
enum ERC721Log {
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
value: U256,
},
Eee {
#[indexed]
- aaa: address,
+ aaa: Address,
bbb: U256,
},
}
crates/evm-coder/tests/solidity_generation.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/solidity_generation.rs
+++ b/crates/evm-coder/tests/solidity_generation.rs
@@ -25,25 +25,25 @@
unreachable!()
}
/// Get balance of specified owner
- fn balance_of(&self, _owner: address) -> Result<U256> {
+ fn balance_of(&self, _owner: Address) -> Result<U256> {
unreachable!()
}
- fn transfer(&mut self, _caller: caller, _to: address, _value: U256) -> Result<bool> {
+ fn transfer(&mut self, _caller: caller, _to: Address, _value: U256) -> Result<bool> {
unreachable!()
}
fn transfer_from(
&mut self,
_caller: caller,
- _from: address,
- _to: address,
+ _from: Address,
+ _to: Address,
_value: U256,
) -> Result<bool> {
unreachable!()
}
- fn approve(&mut self, _caller: caller, _spender: address, _value: U256) -> Result<bool> {
+ fn approve(&mut self, _caller: caller, _spender: Address, _value: U256) -> Result<bool> {
unreachable!()
}
- fn allowance(&self, _owner: address, _spender: address) -> Result<U256> {
+ fn allowance(&self, _owner: Address, _spender: Address) -> Result<U256> {
unreachable!()
}
}
pallets/common/src/erc.rsdiffbeforeafterboth--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -43,30 +43,30 @@
CollectionCreated {
/// Collection owner.
#[indexed]
- owner: address,
+ owner: Address,
/// Collection ID.
#[indexed]
- collection_id: address,
+ collection_id: Address,
},
/// The collection has been destroyed.
CollectionDestroyed {
/// Collection ID.
#[indexed]
- collection_id: address,
+ collection_id: Address,
},
/// The collection has been changed.
CollectionChanged {
/// Collection ID.
#[indexed]
- collection_id: address,
+ collection_id: Address,
},
/// The token has been changed.
TokenChanged {
/// Collection ID.
#[indexed]
- collection_id: address,
+ collection_id: Address,
/// Token ID.
token_id: U256,
},
@@ -208,7 +208,7 @@
///
/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
#[solidity(hide)]
- fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<()> {
+ fn set_collection_sponsor(&mut self, caller: caller, sponsor: Address) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -351,7 +351,7 @@
}
/// Get contract address.
- fn contract_address(&self) -> Result<address> {
+ fn contract_address(&self) -> Result<Address> {
Ok(crate::eth::collection_id_to_address(self.id))
}
@@ -388,7 +388,7 @@
/// Add collection admin.
/// @param newAdmin Address of the added administrator.
#[solidity(hide)]
- fn add_collection_admin(&mut self, caller: caller, new_admin: address) -> Result<()> {
+ fn add_collection_admin(&mut self, caller: caller, new_admin: Address) -> Result<()> {
self.consume_store_reads_and_writes(2, 2)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -401,7 +401,7 @@
///
/// @param admin Address of the removed administrator.
#[solidity(hide)]
- fn remove_collection_admin(&mut self, caller: caller, admin: address) -> Result<()> {
+ fn remove_collection_admin(&mut self, caller: caller, admin: Address) -> Result<()> {
self.consume_store_reads_and_writes(2, 2)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -437,7 +437,7 @@
&mut self,
caller: caller,
enable: bool,
- collections: Vec<address>,
+ collections: Vec<Address>,
) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
@@ -526,7 +526,7 @@
///
/// @param user Address of a trusted user.
#[solidity(hide)]
- fn add_to_collection_allow_list(&mut self, caller: caller, user: address) -> Result<()> {
+ fn add_to_collection_allow_list(&mut self, caller: caller, user: Address) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -555,7 +555,7 @@
///
/// @param user Address of a removed user.
#[solidity(hide)]
- fn remove_from_collection_allow_list(&mut self, caller: caller, user: address) -> Result<()> {
+ fn remove_from_collection_allow_list(&mut self, caller: caller, user: Address) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -599,7 +599,7 @@
/// @param user account to verify
/// @return "true" if account is the owner or admin
#[solidity(hide, rename_selector = "isOwnerOrAdmin")]
- fn is_owner_or_admin_eth(&self, user: address) -> Result<bool> {
+ fn is_owner_or_admin_eth(&self, user: Address) -> Result<bool> {
let user = T::CrossAccountId::from_eth(user);
Ok(self.is_owner_or_admin(&user))
}
@@ -640,7 +640,7 @@
/// @dev Owner can be changed only by current owner
/// @param newOwner new owner account
#[solidity(hide, rename_selector = "changeCollectionOwner")]
- fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<()> {
+ fn set_owner(&mut self, caller: caller, new_owner: Address) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
pallets/common/src/eth.rsdiffbeforeafterboth--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -18,7 +18,7 @@
use alloc::format;
use sp_std::{vec, vec::Vec};
-use evm_coder::{AbiCoder, types::address};
+use evm_coder::{AbiCoder, types::Address};
pub use pallet_evm::{Config, account::CrossAccountId};
use sp_core::{H160, U256};
use up_data_structs::CollectionId;
@@ -30,7 +30,7 @@
];
/// Maps the ethereum address of the collection in substrate.
-pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {
+pub fn map_eth_to_id(eth: &Address) -> Option<CollectionId> {
if eth[0..16] != ETH_COLLECTION_PREFIX {
return None;
}
@@ -40,7 +40,7 @@
}
/// Maps the substrate collection id in ethereum.
-pub fn collection_id_to_address(id: CollectionId) -> H160 {
+pub fn collection_id_to_address(id: CollectionId) -> Address {
let mut out = [0; 20];
out[0..16].copy_from_slice(Ð_COLLECTION_PREFIX);
out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));
@@ -48,7 +48,7 @@
}
/// Check if the ethereum address is a collection.
-pub fn is_collection(address: &H160) -> bool {
+pub fn is_collection(address: &Address) -> bool {
address[0..16] == ETH_COLLECTION_PREFIX
}
@@ -66,7 +66,7 @@
/// Cross account struct
#[derive(Debug, Default, AbiCoder)]
pub struct CrossAddress {
- pub(crate) eth: address,
+ pub(crate) eth: Address,
pub(crate) sub: U256,
}
pallets/evm-contract-helpers/src/eth.rsdiffbeforeafterboth--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -49,25 +49,25 @@
ContractSponsorSet {
/// Contract address of the affected collection.
#[indexed]
- contract_address: address,
+ contract_address: Address,
/// New sponsor address.
- sponsor: address,
+ sponsor: Address,
},
/// New sponsor was confirm.
ContractSponsorshipConfirmed {
/// Contract address of the affected collection.
#[indexed]
- contract_address: address,
+ contract_address: Address,
/// New sponsor address.
- sponsor: address,
+ sponsor: Address,
},
/// Collection sponsor was removed.
ContractSponsorRemoved {
/// Contract address of the affected collection.
#[indexed]
- contract_address: address,
+ contract_address: Address,
},
}
@@ -96,7 +96,7 @@
/// @dev Returns zero address if contract does not exists
/// @param contractAddress Contract to get owner of
/// @return address Owner of contract
- fn contract_owner(&self, contract_address: address) -> Result<address> {
+ fn contract_owner(&self, contract_address: Address) -> Result<Address> {
Ok(<Owner<T>>::get(contract_address))
}
@@ -106,8 +106,8 @@
fn set_sponsor(
&mut self,
caller: caller,
- contract_address: address,
- sponsor: address,
+ contract_address: Address,
+ sponsor: Address,
) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -125,7 +125,7 @@
/// Set contract as self sponsored.
///
/// @param contractAddress Contract for which a self sponsoring is being enabled.
- fn self_sponsored_enable(&mut self, caller: caller, contract_address: address) -> Result<()> {
+ fn self_sponsored_enable(&mut self, caller: caller, contract_address: Address) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -146,7 +146,7 @@
/// Remove sponsor.
///
/// @param contractAddress Contract for which a sponsorship is being removed.
- fn remove_sponsor(&mut self, caller: caller, contract_address: address) -> Result<()> {
+ fn remove_sponsor(&mut self, caller: caller, contract_address: Address) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -161,7 +161,7 @@
/// @dev Caller must be same that set via [`setSponsor`].
///
/// @param contractAddress Сontract for which need to confirm sponsorship.
- fn confirm_sponsorship(&mut self, caller: caller, contract_address: address) -> Result<()> {
+ fn confirm_sponsorship(&mut self, caller: caller, contract_address: Address) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -175,7 +175,7 @@
///
/// @param contractAddress The contract for which a sponsor is requested.
/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
- fn sponsor(&self, contract_address: address) -> Result<Option<eth::CrossAddress>> {
+ fn sponsor(&self, contract_address: Address) -> Result<Option<eth::CrossAddress>> {
Ok(match Pallet::<T>::get_sponsor(contract_address) {
Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),
None => None,
@@ -186,7 +186,7 @@
///
/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.
/// @return **true** if contract has confirmed sponsor.
- fn has_sponsor(&self, contract_address: address) -> Result<bool> {
+ fn has_sponsor(&self, contract_address: Address) -> Result<bool> {
Ok(Pallet::<T>::get_sponsor(contract_address).is_some())
}
@@ -194,21 +194,21 @@
///
/// @param contractAddress The contract for which the presence of a pending sponsor is checked.
/// @return **true** if contract has pending sponsor.
- fn has_pending_sponsor(&self, contract_address: address) -> Result<bool> {
+ fn has_pending_sponsor(&self, contract_address: Address) -> Result<bool> {
Ok(match Sponsoring::<T>::get(contract_address) {
SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => false,
SponsorshipState::Unconfirmed(_) => true,
})
}
- fn sponsoring_enabled(&self, contract_address: address) -> Result<bool> {
+ fn sponsoring_enabled(&self, contract_address: Address) -> Result<bool> {
Ok(<Pallet<T>>::sponsoring_mode(contract_address) != SponsoringModeT::Disabled)
}
fn set_sponsoring_mode(
&mut self,
caller: caller,
- contract_address: address,
+ contract_address: Address,
mode: SponsoringModeT,
) -> Result<()> {
self.recorder().consume_sload()?;
@@ -223,7 +223,7 @@
/// Get current contract sponsoring rate limit
/// @param contractAddress Contract to get sponsoring rate limit of
/// @return uint32 Amount of blocks between two sponsored transactions
- fn sponsoring_rate_limit(&self, contract_address: address) -> Result<u32> {
+ fn sponsoring_rate_limit(&self, contract_address: Address) -> Result<u32> {
self.recorder().consume_sload()?;
Ok(<SponsoringRateLimit<T>>::get(contract_address)
@@ -240,7 +240,7 @@
fn set_sponsoring_rate_limit(
&mut self,
caller: caller,
- contract_address: address,
+ contract_address: Address,
rate_limit: u32,
) -> Result<()> {
self.recorder().consume_sload()?;
@@ -260,7 +260,7 @@
fn set_sponsoring_fee_limit(
&mut self,
caller: caller,
- contract_address: address,
+ contract_address: Address,
fee_limit: U256,
) -> Result<()> {
self.recorder().consume_sload()?;
@@ -276,7 +276,7 @@
/// @param contractAddress Contract to get sponsoring fee limit of
/// @return uint256 Maximum amount of fee that could be spent by single
/// transaction
- fn sponsoring_fee_limit(&self, contract_address: address) -> Result<U256> {
+ fn sponsoring_fee_limit(&self, contract_address: Address) -> Result<U256> {
self.recorder().consume_sload()?;
Ok(get_sponsoring_fee_limit::<T>(contract_address))
@@ -287,7 +287,7 @@
/// @param contractAddress Contract to check allowlist of
/// @param user User to check
/// @return bool Is specified users exists in contract allowlist
- fn allowed(&self, contract_address: address, user: address) -> Result<bool> {
+ fn allowed(&self, contract_address: Address, user: Address) -> Result<bool> {
self.0.consume_sload()?;
Ok(<Pallet<T>>::allowed(contract_address, user))
}
@@ -301,8 +301,8 @@
fn toggle_allowed(
&mut self,
caller: caller,
- contract_address: address,
- user: address,
+ contract_address: Address,
+ user: Address,
is_allowed: bool,
) -> Result<()> {
self.recorder().consume_sload()?;
@@ -320,7 +320,7 @@
/// in case of allowlist access enabled, only users from allowlist may call this contract
/// @param contractAddress Contract to get allowlist access of
/// @return bool Is specified contract has allowlist access enabled
- fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {
+ fn allowlist_enabled(&self, contract_address: Address) -> Result<bool> {
Ok(<AllowlistEnabled<T>>::get(contract_address))
}
@@ -330,7 +330,7 @@
fn toggle_allowlist(
&mut self,
caller: caller,
- contract_address: address,
+ contract_address: Address,
enabled: bool,
) -> Result<()> {
self.recorder().consume_sload()?;
@@ -441,7 +441,7 @@
}
}
-fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> U256 {
+fn get_sponsoring_fee_limit<T: Config>(contract_address: Address) -> U256 {
<SponsoringFeeLimit<T>>::get(contract_address)
.get(&0xffffffff)
.cloned()
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -43,16 +43,16 @@
pub enum ERC20Events {
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
value: U256,
},
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- spender: address,
+ spender: Address,
value: U256,
},
}
@@ -79,14 +79,14 @@
unreachable!()
})
}
- fn balance_of(&self, owner: address) -> Result<U256> {
+ fn balance_of(&self, owner: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let balance = <Balance<T>>::get((self.id, owner));
Ok(balance.into())
}
#[weight(<SelfWeightOf<T>>::transfer())]
- fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+ fn transfer(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -102,8 +102,8 @@
fn transfer_from(
&mut self,
caller: caller,
- from: address,
- to: address,
+ from: Address,
+ to: Address,
amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -119,7 +119,7 @@
Ok(true)
}
#[weight(<SelfWeightOf<T>>::approve())]
- fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
+ fn approve(&mut self, caller: caller, spender: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let spender = T::CrossAccountId::from_eth(spender);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -128,7 +128,7 @@
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
- fn allowance(&self, owner: address, spender: address) -> Result<U256> {
+ fn allowance(&self, owner: Address, spender: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let spender = T::CrossAccountId::from_eth(spender);
@@ -137,7 +137,7 @@
}
/// @notice Returns collection helper contract address
- fn collection_helper_address(&self) -> Result<address> {
+ fn collection_helper_address(&self) -> Result<Address> {
Ok(T::ContractAddress::get())
}
}
@@ -148,7 +148,7 @@
/// @param to account that will receive minted tokens
/// @param amount amount of tokens to mint
#[weight(<SelfWeightOf<T>>::create_item())]
- fn mint(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+ fn mint(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -214,7 +214,7 @@
/// @param amount The amount that will be burnt.
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::burn_from())]
- fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
+ fn burn_from(&mut self, caller: caller, from: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -254,7 +254,7 @@
/// Mint tokens for multiple accounts.
/// @param amounts array of pairs of account address and amount
#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
- fn mint_bulk(&mut self, caller: caller, amounts: Vec<(address, U256)>) -> Result<bool> {
+ fn mint_bulk(&mut self, caller: caller, amounts: Vec<(Address, U256)>) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let budget = self
.recorder
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -261,9 +261,9 @@
/// any transfer, the approved address for that NFT (if any) is reset to none.
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
#[indexed]
token_id: U256,
},
@@ -273,9 +273,9 @@
/// address for that NFT (if any) is reset to none.
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- approved: address,
+ approved: Address,
#[indexed]
token_id: U256,
},
@@ -284,9 +284,9 @@
#[allow(dead_code)]
ApprovalForAll {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- operator: address,
+ operator: Address,
approved: bool,
},
}
@@ -373,7 +373,7 @@
}
/// @dev Not implemented
- fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
+ fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -396,7 +396,7 @@
/// function throws for queries about the zero address.
/// @param owner An address for whom to query the balance
/// @return The number of NFTs owned by `owner`, possibly zero
- fn balance_of(&self, owner: address) -> Result<U256> {
+ fn balance_of(&self, owner: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
/// about them do throw.
/// @param tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
- fn owner_of(&self, token_id: U256) -> Result<address> {
+ fn owner_of(&self, token_id: U256) -> Result<Address> {
self.consume_store_reads(1)?;
let token: TokenId = token_id.try_into()?;
Ok(*<TokenData<T>>::get((self.id, token))
@@ -419,8 +419,8 @@
#[solidity(rename_selector = "safeTransferFrom")]
fn safe_transfer_from_with_data(
&mut self,
- _from: address,
- _to: address,
+ _from: Address,
+ _to: Address,
_token_id: U256,
_data: bytes,
) -> Result<()> {
@@ -428,7 +428,7 @@
Err("not implemented".into())
}
/// @dev Not implemented
- fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
+ fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -446,8 +446,8 @@
fn transfer_from(
&mut self,
caller: caller,
- from: address,
- to: address,
+ from: Address,
+ to: Address,
token_id: U256,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -470,7 +470,7 @@
/// @param approved The new approved NFT controller
/// @param tokenId The NFT to approve
#[weight(<SelfWeightOf<T>>::approve())]
- fn approve(&mut self, caller: caller, approved: address, token_id: U256) -> Result<()> {
+ fn approve(&mut self, caller: caller, approved: Address, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let approved = T::CrossAccountId::from_eth(approved);
let token = token_id.try_into()?;
@@ -488,7 +488,7 @@
fn set_approval_for_all(
&mut self,
caller: caller,
- operator: address,
+ operator: Address,
approved: bool,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -500,14 +500,14 @@
}
/// @dev Not implemented
- fn get_approved(&self, _token_id: U256) -> Result<address> {
+ fn get_approved(&self, _token_id: U256) -> Result<Address> {
// TODO: Not implemetable
Err("not implemented".into())
}
/// @notice Tells whether the given `owner` approves the `operator`.
#[weight(<SelfWeightOf<T>>::allowance_for_all())]
- fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+ fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {
let owner = T::CrossAccountId::from_eth(owner);
let operator = T::CrossAccountId::from_eth(operator);
@@ -539,7 +539,7 @@
/// @param to The new owner
/// @return uint256 The id of the newly minted token
#[weight(<SelfWeightOf<T>>::create_item())]
- fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+ fn mint(&mut self, caller: caller, to: Address) -> Result<U256> {
let token_id: U256 = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?
@@ -555,7 +555,7 @@
/// @param tokenId ID of the minted NFT
#[solidity(hide, rename_selector = "mint")]
#[weight(<SelfWeightOf<T>>::create_item())]
- fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
+ fn mint_check_id(&mut self, caller: caller, to: Address, token_id: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token_id: u32 = token_id.try_into()?;
@@ -594,7 +594,7 @@
fn mint_with_token_uri(
&mut self,
caller: caller,
- to: address,
+ to: Address,
token_uri: string,
) -> Result<U256> {
let token_id: U256 = <TokensMinted<T>>::get(self.id)
@@ -616,7 +616,7 @@
fn mint_with_token_uri_check_id(
&mut self,
caller: caller,
- to: address,
+ to: Address,
token_id: U256,
token_uri: string,
) -> Result<bool> {
@@ -784,7 +784,7 @@
/// @param to The new owner
/// @param tokenId The NFT to transfer
#[weight(<SelfWeightOf<T>>::transfer())]
- fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
+ fn transfer(&mut self, caller: caller, to: Address, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token = token_id.try_into()?;
@@ -853,7 +853,7 @@
/// @param tokenId The NFT to transfer
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::burn_from())]
- fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
+ fn burn_from(&mut self, caller: caller, from: Address, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let token = token_id.try_into()?;
@@ -907,7 +907,7 @@
/// @param tokenIds IDs of the minted NFTs
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
- fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
+ fn mint_bulk(&mut self, caller: caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -947,7 +947,7 @@
fn mint_bulk_with_token_uri(
&mut self,
caller: caller,
- to: address,
+ to: Address,
tokens: Vec<(U256, string)>,
) -> Result<bool> {
let key = key::url();
@@ -1035,7 +1035,7 @@
}
/// @notice Returns collection helper contract address
- fn collection_helper_address(&self) -> Result<address> {
+ fn collection_helper_address(&self) -> Result<Address> {
Ok(T::ContractAddress::get())
}
}
pallets/refungible/src/erc.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -262,18 +262,18 @@
/// may be created and assigned without emitting Transfer.
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
#[indexed]
token_id: U256,
},
/// @dev Not supported
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- approved: address,
+ approved: Address,
#[indexed]
token_id: U256,
},
@@ -281,9 +281,9 @@
#[allow(dead_code)]
ApprovalForAll {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- operator: address,
+ operator: Address,
approved: bool,
},
}
@@ -370,7 +370,7 @@
}
/// Not implemented
- fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
+ fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -393,7 +393,7 @@
/// function throws for queries about the zero address.
/// @param owner An address for whom to query the balance
/// @return The number of RFTs owned by `owner`, possibly zero
- fn balance_of(&self, owner: address) -> Result<U256> {
+ fn balance_of(&self, owner: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
/// the tokens that are partially owned.
/// @param tokenId The identifier for an RFT
/// @return The address of the owner of the RFT
- fn owner_of(&self, token_id: U256) -> Result<address> {
+ fn owner_of(&self, token_id: U256) -> Result<Address> {
self.consume_store_reads(2)?;
let token = token_id.try_into()?;
let owner = <Pallet<T>>::token_owner(self.id, token);
@@ -420,8 +420,8 @@
#[solidity(rename_selector = "safeTransferFrom")]
fn safe_transfer_from_with_data(
&mut self,
- _from: address,
- _to: address,
+ _from: Address,
+ _to: Address,
_token_id: U256,
_data: bytes,
) -> Result<()> {
@@ -431,7 +431,7 @@
/// @dev Not implemented
#[solidity(rename_selector = "safeTransferFrom")]
- fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
+ fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -450,8 +450,8 @@
fn transfer_from(
&mut self,
caller: caller,
- from: address,
- to: address,
+ from: Address,
+ to: Address,
token_id: U256,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -472,7 +472,7 @@
}
/// @dev Not implemented
- fn approve(&mut self, _caller: caller, _approved: address, _token_id: U256) -> Result<()> {
+ fn approve(&mut self, _caller: caller, _approved: Address, _token_id: U256) -> Result<()> {
Err("not implemented".into())
}
@@ -484,7 +484,7 @@
fn set_approval_for_all(
&mut self,
caller: caller,
- operator: address,
+ operator: Address,
approved: bool,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -496,14 +496,14 @@
}
/// @dev Not implemented
- fn get_approved(&self, _token_id: U256) -> Result<address> {
+ fn get_approved(&self, _token_id: U256) -> Result<Address> {
// TODO: Not implemetable
Err("not implemented".into())
}
/// @notice Tells whether the given `owner` approves the `operator`.
#[weight(<SelfWeightOf<T>>::allowance_for_all())]
- fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+ fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {
let owner = T::CrossAccountId::from_eth(owner);
let operator = T::CrossAccountId::from_eth(operator);
@@ -570,7 +570,7 @@
/// @param to The new owner
/// @return uint256 The id of the newly minted token
#[weight(<SelfWeightOf<T>>::create_item())]
- fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+ fn mint(&mut self, caller: caller, to: Address) -> Result<U256> {
let token_id: U256 = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?
@@ -586,7 +586,7 @@
/// @param tokenId ID of the minted RFT
#[solidity(hide, rename_selector = "mint")]
#[weight(<SelfWeightOf<T>>::create_item())]
- fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
+ fn mint_check_id(&mut self, caller: caller, to: Address, token_id: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token_id: u32 = token_id.try_into()?;
@@ -630,7 +630,7 @@
fn mint_with_token_uri(
&mut self,
caller: caller,
- to: address,
+ to: Address,
token_uri: string,
) -> Result<U256> {
let token_id: U256 = <TokensMinted<T>>::get(self.id)
@@ -652,7 +652,7 @@
fn mint_with_token_uri_check_id(
&mut self,
caller: caller,
- to: address,
+ to: Address,
token_id: U256,
token_uri: string,
) -> Result<bool> {
@@ -800,7 +800,7 @@
/// @param to The new owner
/// @param tokenId The RFT to transfer
#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
- fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
+ fn transfer(&mut self, caller: caller, to: Address, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token = token_id.try_into()?;
@@ -883,7 +883,7 @@
/// @param tokenId The RFT to transfer
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::burn_from())]
- fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
+ fn burn_from(&mut self, caller: caller, from: Address, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let token = token_id.try_into()?;
@@ -944,7 +944,7 @@
/// @param tokenIds IDs of the minted RFTs
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
- fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
+ fn mint_bulk(&mut self, caller: caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -990,7 +990,7 @@
fn mint_bulk_with_token_uri(
&mut self,
caller: caller,
- to: address,
+ to: Address,
tokens: Vec<(U256, string)>,
) -> Result<bool> {
let key = key::url();
@@ -1088,7 +1088,7 @@
/// Returns EVM address for refungible token
///
/// @param token ID of the token
- fn token_contract_address(&self, token: U256) -> Result<address> {
+ fn token_contract_address(&self, token: U256) -> Result<Address> {
Ok(T::EvmTokenAddressMapping::token_to_address(
self.id,
token.try_into().map_err(|_| "token id overflow")?,
@@ -1096,7 +1096,7 @@
}
/// @notice Returns collection helper contract address
- fn collection_helper_address(&self) -> Result<address> {
+ fn collection_helper_address(&self) -> Result<Address> {
Ok(T::ContractAddress::get())
}
}
pallets/refungible/src/erc_token.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -52,7 +52,7 @@
#[solidity_interface(name = ERC1633)]
impl<T: Config> RefungibleTokenHandle<T> {
- fn parent_token(&self) -> Result<address> {
+ fn parent_token(&self) -> Result<Address> {
Ok(collection_id_to_address(self.id))
}
@@ -69,18 +69,18 @@
/// of burning tokens the transfer is to 0.
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
value: U256,
},
/// @dev This event is emitted when the amount of tokens (value) is approved
/// by the owner to be used by the spender.
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- spender: address,
+ spender: Address,
value: U256,
},
}
@@ -118,7 +118,7 @@
/// @dev Gets the balance of the specified address.
/// @param owner The address to query the balance of.
/// @return An uint256 representing the amount owned by the passed address.
- fn balance_of(&self, owner: address) -> Result<U256> {
+ fn balance_of(&self, owner: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let balance = <Balance<T>>::get((self.id, self.1, owner));
@@ -129,7 +129,7 @@
/// @param to The address to transfer to.
/// @param amount The amount to be transferred.
#[weight(<CommonWeights<T>>::transfer())]
- fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+ fn transfer(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -150,8 +150,8 @@
fn transfer_from(
&mut self,
caller: caller,
- from: address,
- to: address,
+ from: Address,
+ to: Address,
amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -175,7 +175,7 @@
/// @param spender The address which will spend the funds.
/// @param amount The amount of tokens to be spent.
#[weight(<SelfWeightOf<T>>::approve())]
- fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
+ fn approve(&mut self, caller: caller, spender: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let spender = T::CrossAccountId::from_eth(spender);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -189,7 +189,7 @@
/// @param owner address The address which owns the funds.
/// @param spender address The address which will spend the funds.
/// @return A uint256 specifying the amount of tokens still available for the spender.
- fn allowance(&self, owner: address, spender: address) -> Result<U256> {
+ fn allowance(&self, owner: Address, spender: Address) -> Result<U256> {
self.consume_store_reads(1)?;
let owner = T::CrossAccountId::from_eth(owner);
let spender = T::CrossAccountId::from_eth(spender);
@@ -209,7 +209,7 @@
/// @param amount The amount that will be burnt.
#[weight(<SelfWeightOf<T>>::burn_from())]
#[solidity(hide)]
- fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
+ fn burn_from(&mut self, caller: caller, from: Address, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
pallets/unique/src/eth/mod.rsdiffbeforeafterboth--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -93,7 +93,7 @@
collection_mode: CollectionMode,
description: string,
token_prefix: string,
-) -> Result<address> {
+) -> Result<Address> {
let (caller, name, description, token_prefix) =
convert_data::<T>(caller, name, description, token_prefix)?;
let data = CreateCollectionData {
@@ -154,7 +154,7 @@
name: string,
description: string,
token_prefix: string,
- ) -> Result<address> {
+ ) -> Result<Address> {
let (caller, name, description, token_prefix) =
convert_data::<T>(caller, name, description, token_prefix)?;
let data = CreateCollectionData {
@@ -193,7 +193,7 @@
name: string,
description: string,
token_prefix: string,
- ) -> Result<address> {
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -213,7 +213,7 @@
name: string,
description: string,
token_prefix: string,
- ) -> Result<address> {
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -234,7 +234,7 @@
decimals: u8,
description: string,
token_prefix: string,
- ) -> Result<address> {
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -249,7 +249,7 @@
fn make_collection_metadata_compatible(
&mut self,
caller: caller,
- collection: address,
+ collection: Address,
base_uri: string,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -334,7 +334,7 @@
}
#[weight(<SelfWeightOf<T>>::destroy_collection())]
- fn destroy_collection(&mut self, caller: caller, collection_address: address) -> Result<()> {
+ fn destroy_collection(&mut self, caller: caller, collection_address: Address) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let collection_id = pallet_common::eth::map_eth_to_id(&collection_address)
@@ -346,7 +346,7 @@
/// Check if a collection exists
/// @param collectionAddress Address of the collection in question
/// @return bool Does the collection exist?
- fn is_collection_exist(&self, _caller: caller, collection_address: address) -> Result<bool> {
+ fn is_collection_exist(&self, _caller: caller, collection_address: Address) -> Result<bool> {
if let Some(id) = pallet_common::eth::map_eth_to_id(&collection_address) {
let collection_id = id;
return Ok(<CollectionById<T>>::contains_key(collection_id));
@@ -366,14 +366,14 @@
/// Returns address of a collection.
/// @param collectionId - CollectionId of the collection
/// @return eth mirror address of the collection
- fn collection_address(&self, collection_id: u32) -> Result<address> {
+ fn collection_address(&self, collection_id: u32) -> Result<Address> {
Ok(collection_id_to_address(collection_id.into()))
}
/// Returns collectionId of a collection.
/// @param collectionAddress - Eth address of the collection
/// @return collectionId of the collection
- fn collection_id(&self, collection_address: address) -> Result<u32> {
+ fn collection_id(&self, collection_address: Address) -> Result<u32> {
map_eth_to_id(&collection_address)
.map(|id| id.0)
.ok_or(Error::Revert(format!(