difftreelog
Merge pull request #825 from UniqueNetwork/feature/evm_coder_types_refactor
in: master
Feature/evm_coder_types_refactor
39 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2330,7 +2330,6 @@
"hex",
"hex-literal",
"impl-trait-for-tuples",
- "pallet-evm",
"primitive-types 0.12.1",
"sha3-const",
"similar-asserts",
crates/evm-coder/Cargo.tomldiffbeforeafterboth--- a/crates/evm-coder/Cargo.toml
+++ b/crates/evm-coder/Cargo.toml
@@ -19,8 +19,6 @@
# We have tuple-heavy code in solidity.rs
impl-trait-for-tuples = "0.2.2"
-pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.36" }
-
[dev-dependencies]
# We want to assert some large binary blobs equality in tests
hex = "0.4.3"
crates/evm-coder/procedural/src/solidity_interface.rsdiffbeforeafterboth--- a/crates/evm-coder/procedural/src/solidity_interface.rs
+++ b/crates/evm-coder/procedural/src/solidity_interface.rs
@@ -347,14 +347,14 @@
fn is_value(&self) -> bool {
if let Ok(ident) = self.plain() {
- return ident == "value";
+ return ident == "Value";
}
false
}
fn is_caller(&self) -> bool {
if let Ok(ident) = self.plain() {
- return ident == "caller";
+ return ident == "Caller";
}
false
}
@@ -610,7 +610,7 @@
let custom_signature = self.expand_custom_signature();
quote! {
const #screaming_name_signature: ::evm_coder::custom_signature::SignatureUnit = #custom_signature;
- const #screaming_name: ::evm_coder::types::bytes4 = {
+ const #screaming_name: ::evm_coder::types::Bytes4 = {
let mut sum = ::evm_coder::sha3_const::Keccak256::new();
let mut pos = 0;
while pos < Self::#screaming_name_signature.len {
@@ -974,7 +974,7 @@
#consts
)*
/// Return this call ERC165 selector
- pub const fn interface_id() -> ::evm_coder::types::bytes4 {
+ pub const fn interface_id() -> ::evm_coder::types::Bytes4 {
let mut interface_id = 0;
#(#interface_id)*
#(#inline_interface_id)*
@@ -999,7 +999,7 @@
)*),
};
- let mut out = ::evm_coder::types::string::new();
+ let mut out = ::evm_coder::types::String::new();
if #solidity_name.starts_with("Inline") {
out.push_str("/// @dev inlined interface\n");
}
@@ -1019,7 +1019,7 @@
}
}
impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {
- fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
+ fn parse(method_id: ::evm_coder::types::Bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
use ::evm_coder::abi::AbiRead;
match method_id {
::evm_coder::ERC165Call::INTERFACE_ID => return Ok(
@@ -1041,7 +1041,7 @@
#gen_where
{
/// Is this contract implements specified ERC165 selector
- pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {
+ pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::Bytes4) -> bool {
interface_id != u32::to_be_bytes(0xffffff) && (
interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||
interface_id == Self::interface_id()
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
@@ -137,7 +137,7 @@
Self::#name {#(
#fields,
)*} => {
- topics.push(topic::from(Self::#name_screaming));
+ topics.push(::evm_coder::types::Topic::from(Self::#name_screaming));
#(
topics.push(#indexed.to_topic());
)*
@@ -222,7 +222,7 @@
#solidity_functions,
)*),
};
- let mut out = string::new();
+ let mut out = ::evm_coder::types::String::new();
out.push_str("/// @dev inlined interface\n");
let _ = interface.format(is_impl, &mut out, tc);
tc.collect(out);
@@ -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/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -63,27 +63,27 @@
impl_abi!(u128, uint128, false);
impl_abi!(U256, uint256, false);
impl_abi!(H160, address, false);
-impl_abi!(string, string, true);
+impl_abi!(String, string, true);
impl_abi_writeable!(&str, string);
-impl_abi_type!(bytes, bytes, true);
+impl_abi_type!(Bytes, bytes, true);
-impl AbiRead for bytes {
- fn abi_read(reader: &mut AbiReader) -> Result<bytes> {
- Ok(bytes(reader.bytes()?))
+impl AbiRead for Bytes {
+ fn abi_read(reader: &mut AbiReader) -> Result<Bytes> {
+ Ok(Bytes(reader.bytes()?))
}
}
-impl AbiWrite for bytes {
+impl AbiWrite for Bytes {
fn abi_write(&self, writer: &mut AbiWriter) {
writer.bytes(self.0.as_slice())
}
}
-impl_abi_type!(bytes4, bytes4, false);
-impl AbiRead for bytes4 {
- fn abi_read(reader: &mut AbiReader) -> Result<bytes4> {
+impl_abi_type!(Bytes4, bytes4, false);
+impl AbiRead for Bytes4 {
+ fn abi_read(reader: &mut AbiReader) -> Result<Bytes4> {
reader.bytes4()
}
}
crates/evm-coder/src/abi/mod.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/mod.rs
+++ b/crates/evm-coder/src/abi/mod.rs
@@ -54,7 +54,7 @@
}
}
/// Start reading RLP buffer, parsing first 4 bytes as selector
- pub fn new_call(buf: &'i [u8]) -> Result<(bytes4, Self)> {
+ pub fn new_call(buf: &'i [u8]) -> Result<(Bytes4, Self)> {
if buf.len() < 4 {
return Err(Error::Error(ExitError::OutOfOffset));
}
@@ -148,8 +148,8 @@
}
/// Read [`string`] at current position, then advance
- pub fn string(&mut self) -> Result<string> {
- string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))
+ pub fn string(&mut self) -> Result<String> {
+ String::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))
}
/// Read [`u8`] at current position, then advance
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!(uint8);43}4445#[test]46fn encode_decode_uint32() {47 test_impl_uint!(uint32);48}4950#[test]51fn encode_decode_uint128() {52 test_impl_uint!(uint128);53}5455#[test]56fn encode_decode_uint256() {57 test_impl::<uint256>(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, uint256)>>(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<(uint256, 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<(uint256, 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
@@ -15,7 +15,7 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
use ethereum::Log;
-use primitive_types::{H160, H256};
+use primitive_types::{H160, H256, U256};
use crate::types::*;
@@ -45,7 +45,7 @@
}
}
-impl ToTopic for uint256 {
+impl ToTopic for U256 {
fn to_topic(&self) -> H256 {
let mut out = [0u8; 32];
self.to_big_endian(&mut out);
@@ -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);
@@ -61,7 +61,7 @@
}
}
-impl ToTopic for uint32 {
+impl ToTopic for u32 {
fn to_topic(&self) -> H256 {
let mut out = [0u8; 32];
out[28..32].copy_from_slice(&self.to_be_bytes());
crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -131,33 +131,23 @@
use alloc::{vec::Vec};
use primitive_types::{U256, H160, H256};
- pub type address = H160;
- pub type uint8 = u8;
- pub type uint16 = u16;
- pub type uint32 = u32;
- pub type uint64 = u64;
- pub type uint128 = u128;
- pub type uint256 = U256;
- pub type bytes4 = [u8; 4];
- pub type topic = H256;
+ pub type Address = H160;
+ pub type Bytes4 = [u8; 4];
+ pub type Topic = H256;
#[cfg(not(feature = "std"))]
- pub type string = ::alloc::string::String;
+ pub type String = ::alloc::string::String;
#[cfg(feature = "std")]
- pub type string = ::std::string::String;
+ pub type String = ::std::string::String;
#[derive(Default, Debug, PartialEq, Eq, Clone)]
- pub struct bytes(pub Vec<u8>);
-
- /// Solidity doesn't have `void` type, however we have special implementation
- /// for empty tuple return type
- pub type void = ();
+ pub struct Bytes(pub Vec<u8>);
//#region Special types
/// Makes function payable
- pub type value = U256;
+ pub type Value = U256;
/// Makes function caller-sensitive
- pub type caller = address;
+ pub type Caller = Address;
//#endregion
/// Ethereum typed call message, similar to solidity
@@ -172,20 +162,20 @@
pub value: U256,
}
- impl From<Vec<u8>> for bytes {
+ impl From<Vec<u8>> for Bytes {
fn from(src: Vec<u8>) -> Self {
Self(src)
}
}
#[allow(clippy::from_over_into)]
- impl Into<Vec<u8>> for bytes {
+ impl Into<Vec<u8>> for Bytes {
fn into(self) -> Vec<u8> {
self.0
}
}
- impl bytes {
+ impl Bytes {
#[must_use]
pub fn len(&self) -> usize {
self.0.len()
@@ -201,7 +191,7 @@
/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro
pub trait Call: Sized {
/// Parse call buffer into typed call enum
- fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;
+ fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;
}
/// Intended to be used as `#[weight]` output type
@@ -237,22 +227,22 @@
/// implements specified interface
SupportsInterface {
/// Requested interface
- interface_id: types::bytes4,
+ interface_id: types::Bytes4,
},
}
impl ERC165Call {
/// ERC165 selector is provided by standard
- pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);
+ pub const INTERFACE_ID: types::Bytes4 = u32::to_be_bytes(0x01ffc9a7);
}
impl Call for ERC165Call {
- fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {
+ fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {
if selector != Self::INTERFACE_ID {
return Ok(None);
}
Ok(Some(Self::SupportsInterface {
- interface_id: types::bytes4::abi_read(input)?,
+ interface_id: types::Bytes4::abi_read(input)?,
}))
}
}
crates/evm-coder/src/solidity/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity/impls.rs
+++ b/crates/evm-coder/src/solidity/impls.rs
@@ -27,14 +27,14 @@
u64 => "uint64" true = "0",
u128 => "uint128" true = "0",
U256 => "uint256" true = "0",
- bytes4 => "bytes4" true = "bytes4(0)",
+ Bytes4 => "bytes4" true = "bytes4(0)",
H160 => "address" true = "0x0000000000000000000000000000000000000000",
- string => "string" false = "\"\"",
- bytes => "bytes" false = "hex\"\"",
+ String => "string" false = "\"\"",
+ Bytes => "bytes" false = "hex\"\"",
bool => "bool" true = "false",
}
-impl SolidityTypeName for void {
+impl SolidityTypeName for () {
fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
Ok(())
}
@@ -72,10 +72,10 @@
macro_rules! impl_tuples {
($($ident:ident)+) => {
impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleTy for ($($ident,)+) {
- fn fields(tc: &TypeCollector) -> Vec<string> {
+ fn fields(tc: &TypeCollector) -> Vec<String> {
let mut collected = Vec::with_capacity(Self::len());
$({
- let mut out = string::new();
+ let mut out = String::new();
$ident::solidity_name(&mut out, tc).expect("no fmt error");
collected.push(out);
})*;
crates/evm-coder/src/solidity/mod.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity/mod.rs
+++ b/crates/evm-coder/src/solidity/mod.rs
@@ -26,7 +26,7 @@
mod impls;
#[cfg(not(feature = "std"))]
-use alloc::{string::String, vec::Vec, collections::BTreeMap, format};
+use alloc::{vec::Vec, collections::BTreeMap, format};
#[cfg(feature = "std")]
use std::collections::BTreeMap;
use core::{
@@ -42,16 +42,16 @@
pub struct TypeCollector {
/// Code => id
/// id ordering is required to perform topo-sort on the resulting data
- structs: RefCell<BTreeMap<string, usize>>,
- anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
- // generic: RefCell<BTreeMap<string, usize>>,
+ structs: RefCell<BTreeMap<String, usize>>,
+ anonymous: RefCell<BTreeMap<Vec<String>, usize>>,
+ // generic: RefCell<BTreeMap<String, usize>>,
id: Cell<usize>,
}
impl TypeCollector {
pub fn new() -> Self {
Self::default()
}
- pub fn collect(&self, item: string) {
+ pub fn collect(&self, item: String) {
let id = self.next_id();
self.structs.borrow_mut().insert(item, id);
}
@@ -84,7 +84,7 @@
pub fn collect_enum<T: SolidityEnumTy>(&self) -> String {
T::generate_solidity_interface(self)
}
- pub fn finish(self) -> Vec<string> {
+ pub fn finish(self) -> Vec<String> {
let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
data.sort_by_key(|(_, id)| Reverse(*id));
data.into_iter().map(|(code, _)| code).collect()
@@ -360,7 +360,7 @@
pub struct SolidityInterface<F: SolidityFunctions> {
pub docs: &'static [&'static str],
- pub selector: bytes4,
+ pub selector: Bytes4,
pub name: &'static str,
pub is: &'static [&'static str],
pub functions: F,
crates/evm-coder/tests/abi_derive_generation.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/abi_derive_generation.rs
+++ b/crates/evm-coder/tests/abi_derive_generation.rs
@@ -1,6 +1,6 @@
mod test_struct {
use evm_coder_procedural::AbiCoder;
- use evm_coder::types::bytes;
+ use evm_coder::types::Bytes;
#[test]
fn empty_struct() {
@@ -27,13 +27,13 @@
#[derive(AbiCoder, PartialEq, Debug)]
struct TypeStruct2DynamicParam {
_a: String,
- _b: bytes,
+ _b: Bytes,
}
#[derive(AbiCoder, PartialEq, Debug)]
struct TypeStruct2MixedParam {
_a: u8,
- _b: bytes,
+ _b: Bytes,
}
#[derive(AbiCoder, PartialEq, Debug)]
@@ -236,10 +236,10 @@
struct TupleStruct2SimpleParam(u8, u32);
#[derive(AbiCoder, PartialEq, Debug)]
- struct TupleStruct2DynamicParam(String, bytes);
+ struct TupleStruct2DynamicParam(String, Bytes);
#[derive(AbiCoder, PartialEq, Debug)]
- struct TupleStruct2MixedParam(u8, bytes);
+ struct TupleStruct2MixedParam(u8, Bytes);
#[derive(AbiCoder, PartialEq, Debug)]
struct TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam);
@@ -562,8 +562,8 @@
#[test]
fn codec_struct_2_dynamic() {
let _a: String = "some string".into();
- let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
- test_impl::<(String, bytes), TupleStruct2DynamicParam, TypeStruct2DynamicParam>(
+ let _b: Bytes = Bytes(vec![0x11, 0x22, 0x33]);
+ test_impl::<(String, Bytes), TupleStruct2DynamicParam, TypeStruct2DynamicParam>(
(_a.clone(), _b.clone()),
TupleStruct2DynamicParam(_a.clone(), _b.clone()),
TypeStruct2DynamicParam { _a, _b },
@@ -573,8 +573,8 @@
#[test]
fn codec_struct_2_mixed() {
let _a: u8 = 0xff;
- let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
- test_impl::<(u8, bytes), TupleStruct2MixedParam, TypeStruct2MixedParam>(
+ let _b: Bytes = Bytes(vec![0x11, 0x22, 0x33]);
+ test_impl::<(u8, Bytes), TupleStruct2MixedParam, TypeStruct2MixedParam>(
(_a.clone(), _b.clone()),
TupleStruct2MixedParam(_a.clone(), _b.clone()),
TypeStruct2MixedParam { _a, _b },
@@ -605,9 +605,9 @@
#[test]
fn codec_struct_2_derived_dynamic() {
let _a = "some string".to_string();
- let _b = bytes(vec![0x11, 0x22, 0x33]);
+ let _b = Bytes(vec![0x11, 0x22, 0x33]);
test_impl::<
- ((String,), (String, bytes)),
+ ((String,), (String, Bytes)),
TupleStruct2DerivedDynamicParam,
TypeStruct2DerivedDynamicParam,
>(
@@ -626,10 +626,10 @@
#[test]
fn codec_struct_3_derived_mixed() {
let int = 0xff;
- let by = bytes(vec![0x11, 0x22, 0x33]);
+ let by = Bytes(vec![0x11, 0x22, 0x33]);
let string = "some string".to_string();
test_impl::<
- ((u8,), (String, bytes), (u8, bytes)),
+ ((u8,), (String, Bytes), (u8, Bytes)),
TupleStruct3DerivedMixedParam,
TypeStruct3DerivedMixedParam,
>(
crates/evm-coder/tests/conditional_is.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/conditional_is.rs
+++ b/crates/evm-coder/tests/conditional_is.rs
@@ -4,14 +4,14 @@
#[solidity_interface(name = A)]
impl Contract {
- fn method_a() -> Result<void> {
+ fn method_a() -> Result<()> {
Ok(())
}
}
#[solidity_interface(name = B)]
impl Contract {
- fn method_b() -> Result<void> {
+ fn method_b() -> Result<()> {
Ok(())
}
}
crates/evm-coder/tests/generics.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/generics.rs
+++ b/crates/evm-coder/tests/generics.rs
@@ -16,19 +16,20 @@
use std::marker::PhantomData;
use evm_coder::{execution::Result, generate_stubgen, solidity_interface, types::*};
+use primitive_types::U256;
pub struct Generic<T>(PhantomData<T>);
#[solidity_interface(name = GenericIs)]
impl<T> Generic<T> {
- fn test_1(&self) -> Result<uint256> {
+ fn test_1(&self) -> Result<U256> {
unreachable!()
}
}
#[solidity_interface(name = Generic, is(GenericIs))]
impl<T: Into<u32>> Generic<T> {
- fn test_2(&self) -> Result<uint256> {
+ fn test_2(&self) -> Result<U256> {
unreachable!()
}
}
@@ -40,7 +41,7 @@
where
T: core::fmt::Debug,
{
- fn test_3(&self) -> Result<uint256> {
+ fn test_3(&self) -> Result<U256> {
unreachable!()
}
}
crates/evm-coder/tests/log.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/log.rs
+++ b/crates/evm-coder/tests/log.rs
@@ -17,19 +17,20 @@
#![allow(dead_code)]
use evm_coder::{ToLog, types::*};
+use primitive_types::U256;
#[derive(ToLog)]
enum ERC721Log {
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
- value: uint256,
+ to: Address,
+ value: U256,
},
Eee {
#[indexed]
- aaa: address,
- bbb: uint256,
+ aaa: Address,
+ bbb: U256,
},
}
crates/evm-coder/tests/random.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/random.rs
+++ b/crates/evm-coder/tests/random.rs
@@ -19,19 +19,20 @@
use evm_coder::{
abi::AbiType, ToLog, execution::Result, solidity_interface, types::*, solidity, weight,
};
+use primitive_types::U256;
pub struct Impls;
#[solidity_interface(name = OurInterface)]
impl Impls {
- fn fn_a(&self, _input: uint256) -> Result<bool> {
+ fn fn_a(&self, _input: U256) -> Result<bool> {
unreachable!()
}
}
#[solidity_interface(name = OurInterface1)]
impl Impls {
- fn fn_b(&self, _input: uint128) -> Result<uint32> {
+ fn fn_b(&self, _input: u128) -> Result<u32> {
unreachable!()
}
}
@@ -39,12 +40,12 @@
#[derive(ToLog)]
enum OurEvents {
Event1 {
- field1: uint32,
+ field1: u32,
},
Event2 {
- field1: uint32,
+ field1: u32,
#[indexed]
- field2: uint32,
+ field2: u32,
},
}
@@ -56,27 +57,27 @@
)]
impl Impls {
#[solidity(rename_selector = "fnK")]
- fn fn_c(&self, _input: uint32) -> Result<uint8> {
+ fn fn_c(&self, _input: u32) -> Result<u8> {
unreachable!()
}
- fn fn_d(&self, _value: uint32) -> Result<uint32> {
+ fn fn_d(&self, _value: u32) -> Result<u32> {
unreachable!()
}
- fn caller_sensitive(&self, _caller: caller) -> Result<uint8> {
+ fn caller_sensitive(&self, _caller: Caller) -> Result<u8> {
unreachable!()
}
- fn payable(&mut self, _value: value) -> Result<uint8> {
+ fn payable(&mut self, _value: Value) -> Result<u8> {
unreachable!()
}
#[weight(*_weight)]
- fn with_weight(&self, _weight: uint64) -> Result<void> {
+ fn with_weight(&self, _weight: u64) -> Result<()> {
unreachable!()
}
/// Doccoment example
- fn with_doc(&self) -> Result<void> {
+ fn with_doc(&self) -> Result<()> {
unreachable!()
}
}
crates/evm-coder/tests/solidity_generation.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/solidity_generation.rs
+++ b/crates/evm-coder/tests/solidity_generation.rs
@@ -15,34 +15,35 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
use evm_coder::{abi::AbiType, execution::Result, generate_stubgen, solidity_interface, types::*};
+use primitive_types::U256;
pub struct ERC20;
#[solidity_interface(name = ERC20)]
impl ERC20 {
- fn decimals(&self) -> Result<uint8> {
+ fn decimals(&self) -> Result<u8> {
unreachable!()
}
/// Get balance of specified owner
- fn balance_of(&self, _owner: address) -> Result<uint256> {
+ fn balance_of(&self, _owner: Address) -> Result<U256> {
unreachable!()
}
- fn transfer(&mut self, _caller: caller, _to: address, _value: uint256) -> 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,
- _value: uint256,
+ _caller: Caller,
+ _from: Address,
+ _to: Address,
+ _value: U256,
) -> Result<bool> {
unreachable!()
}
- fn approve(&mut self, _caller: caller, _spender: address, _value: uint256) -> Result<bool> {
+ fn approve(&mut self, _caller: Caller, _spender: Address, _value: U256) -> Result<bool> {
unreachable!()
}
- fn allowance(&self, _owner: address, _spender: address) -> Result<uint256> {
+ 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
@@ -26,6 +26,7 @@
};
use pallet_evm_coder_substrate::dispatch_to_evm;
use sp_std::{vec, vec::Vec};
+use sp_core::U256;
use up_data_structs::{
AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
SponsoringRateLimit, SponsorshipState,
@@ -42,32 +43,32 @@
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: uint256,
+ token_id: U256,
},
}
@@ -93,12 +94,7 @@
/// @param value Propery value.
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::set_collection_properties(1))]
- fn set_collection_property(
- &mut self,
- caller: caller,
- key: string,
- value: bytes,
- ) -> Result<void> {
+ fn set_collection_property(&mut self, caller: Caller, key: String, value: Bytes) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let key = <Vec<u8>>::from(key)
.try_into()
@@ -115,9 +111,9 @@
#[weight(<SelfWeightOf<T>>::set_collection_properties(properties.len() as u32))]
fn set_collection_properties(
&mut self,
- caller: caller,
+ caller: Caller,
properties: Vec<eth::Property>,
- ) -> Result<void> {
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let properties = properties
@@ -134,7 +130,7 @@
/// @param key Property key.
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::delete_collection_properties(1))]
- fn delete_collection_property(&mut self, caller: caller, key: string) -> Result<()> {
+ fn delete_collection_property(&mut self, caller: Caller, key: String) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let key = <Vec<u8>>::from(key)
.try_into()
@@ -147,7 +143,7 @@
///
/// @param keys Properties keys.
#[weight(<SelfWeightOf<T>>::delete_collection_properties(keys.len() as u32))]
- fn delete_collection_properties(&mut self, caller: caller, keys: Vec<string>) -> Result<()> {
+ fn delete_collection_properties(&mut self, caller: Caller, keys: Vec<String>) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let keys = keys
.into_iter()
@@ -168,7 +164,7 @@
///
/// @param key Property key.
/// @return bytes The property corresponding to the key.
- fn collection_property(&self, key: string) -> Result<bytes> {
+ fn collection_property(&self, key: String) -> Result<Bytes> {
let key = <Vec<u8>>::from(key)
.try_into()
.map_err(|_| "key too large")?;
@@ -176,14 +172,14 @@
let props = CollectionProperties::<T>::get(self.id);
let prop = props.get(&key).ok_or("key not found")?;
- Ok(bytes(prop.to_vec()))
+ Ok(Bytes(prop.to_vec()))
}
/// Get collection properties.
///
/// @param keys Properties keys. Empty keys for all propertyes.
/// @return Vector of properties key/value pairs.
- fn collection_properties(&self, keys: Vec<string>) -> Result<Vec<eth::Property>> {
+ fn collection_properties(&self, keys: Vec<String>) -> Result<Vec<eth::Property>> {
let keys = keys
.into_iter()
.map(|key| {
@@ -212,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<void> {
+ 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);
@@ -229,9 +225,9 @@
/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
fn set_collection_sponsor_cross(
&mut self,
- caller: caller,
+ caller: Caller,
sponsor: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -252,7 +248,7 @@
/// Collection sponsorship confirmation.
///
/// @dev After setting the sponsor for the collection, it must be confirmed with this function.
- fn confirm_collection_sponsorship(&mut self, caller: caller) -> Result<void> {
+ fn confirm_collection_sponsorship(&mut self, caller: Caller) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -261,7 +257,7 @@
}
/// Remove collection sponsor.
- fn remove_collection_sponsor(&mut self, caller: caller) -> Result<void> {
+ fn remove_collection_sponsor(&mut self, caller: Caller) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
self.remove_sponsor(&caller).map_err(dispatch_to_evm::<T>)
@@ -343,11 +339,7 @@
/// @dev Throws error if limit not found.
/// @param limit Some limit.
#[solidity(rename_selector = "setCollectionLimit")]
- fn set_collection_limit(
- &mut self,
- caller: caller,
- limit: eth::CollectionLimit,
- ) -> Result<void> {
+ fn set_collection_limit(&mut self, caller: Caller, limit: eth::CollectionLimit) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
if !limit.has_value() {
@@ -359,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))
}
@@ -367,9 +359,9 @@
/// @param newAdmin Cross account administrator address.
fn add_collection_admin_cross(
&mut self,
- caller: caller,
+ caller: Caller,
new_admin: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> Result<()> {
self.consume_store_reads_and_writes(2, 2)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -382,9 +374,9 @@
/// @param admin Cross account administrator address.
fn remove_collection_admin_cross(
&mut self,
- caller: caller,
+ caller: Caller,
admin: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> Result<()> {
self.consume_store_reads_and_writes(2, 2)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -396,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<void> {
+ 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);
@@ -409,7 +401,7 @@
///
/// @param admin Address of the removed administrator.
#[solidity(hide)]
- fn remove_collection_admin(&mut self, caller: caller, admin: address) -> Result<void> {
+ 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);
@@ -422,7 +414,7 @@
///
/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
#[solidity(rename_selector = "setCollectionNesting")]
- fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {
+ fn set_nesting_bool(&mut self, caller: Caller, enable: bool) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -443,10 +435,10 @@
#[solidity(rename_selector = "setCollectionNesting")]
fn set_nesting(
&mut self,
- caller: caller,
+ caller: Caller,
enable: bool,
- collections: Vec<address>,
- ) -> Result<void> {
+ collections: Vec<Address>,
+ ) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
if collections.is_empty() {
@@ -511,18 +503,12 @@
}
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
- fn set_collection_access(&mut self, caller: caller, mode: uint8) -> Result<void> {
+ fn set_collection_access(&mut self, caller: Caller, mode: eth::AccessMode) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
let permissions = CollectionPermissions {
- access: Some(match mode {
- 0 => AccessMode::Normal,
- 1 => AccessMode::AllowList,
- _ => return Err("not supported access mode".into()),
- }),
+ access: Some(mode.into()),
..Default::default()
};
<Pallet<T>>::update_permissions(&caller, self, permissions).map_err(dispatch_to_evm::<T>)
@@ -540,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<void> {
+ 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);
@@ -554,9 +540,9 @@
/// @param user User cross account address.
fn add_to_collection_allow_list_cross(
&mut self,
- caller: caller,
+ caller: Caller,
user: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -569,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<void> {
+ 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);
@@ -583,9 +569,9 @@
/// @param user User cross account address.
fn remove_from_collection_allow_list_cross(
&mut self,
- caller: caller,
+ caller: Caller,
user: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -597,7 +583,7 @@
/// Switch permission for minting.
///
/// @param mode Enable if "true".
- fn set_collection_mint_mode(&mut self, caller: caller, mode: bool) -> Result<void> {
+ fn set_collection_mint_mode(&mut self, caller: Caller, mode: bool) -> Result<()> {
self.consume_store_reads_and_writes(1, 1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -613,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))
}
@@ -630,7 +616,7 @@
/// Returns collection type
///
/// @return `Fungible` or `NFT` or `ReFungible`
- fn unique_collection_type(&self) -> Result<string> {
+ fn unique_collection_type(&self) -> Result<String> {
let mode = match self.collection.mode {
CollectionMode::Fungible(_) => "Fungible",
CollectionMode::NFT => "NFT",
@@ -654,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<void> {
+ fn set_owner(&mut self, caller: Caller, new_owner: Address) -> Result<()> {
self.consume_store_writes(1)?;
let caller = T::CrossAccountId::from_eth(caller);
@@ -680,9 +666,9 @@
/// @param newOwner new owner cross account
fn change_collection_owner_cross(
&mut self,
- caller: caller,
+ caller: Caller,
new_owner: eth::CrossAddress,
- ) -> Result<void> {
+ ) -> 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,12 +18,9 @@
use alloc::format;
use sp_std::{vec, vec::Vec};
-use evm_coder::{
- AbiCoder,
- types::{uint256, address},
-};
+use evm_coder::{AbiCoder, types::Address};
pub use pallet_evm::{Config, account::CrossAccountId};
-use sp_core::H160;
+use sp_core::{H160, U256};
use up_data_structs::CollectionId;
// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1
@@ -33,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;
}
@@ -43,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));
@@ -51,12 +48,12 @@
}
/// 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
}
-/// Convert `uint256` to `CrossAccountId`.
-pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId
+/// Convert `U256` to `CrossAccountId`.
+pub fn convert_uint256_to_cross_account<T: Config>(from: U256) -> T::CrossAccountId
where
T::AccountId: From<[u8; 32]>,
{
@@ -69,8 +66,8 @@
/// Cross account struct
#[derive(Debug, Default, AbiCoder)]
pub struct CrossAddress {
- pub(crate) eth: address,
- pub(crate) sub: uint256,
+ pub(crate) eth: Address,
+ pub(crate) sub: U256,
}
impl CrossAddress {
@@ -97,7 +94,7 @@
{
Self {
eth: Default::default(),
- sub: uint256::from_big_endian(account_id.as_ref()),
+ sub: U256::from_big_endian(account_id.as_ref()),
}
}
/// Converts [`CrossAddress`] to `CrossAccountId`.
@@ -121,17 +118,17 @@
/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).
#[derive(Debug, Default, AbiCoder)]
pub struct Property {
- key: evm_coder::types::string,
- value: evm_coder::types::bytes,
+ key: evm_coder::types::String,
+ value: evm_coder::types::Bytes,
}
impl TryFrom<up_data_structs::Property> for Property {
type Error = evm_coder::execution::Error;
fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {
- let key = evm_coder::types::string::from_utf8(from.key.into())
+ let key = evm_coder::types::String::from_utf8(from.key.into())
.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;
- let value = evm_coder::types::bytes(from.value.to_vec());
+ let value = evm_coder::types::Bytes(from.value.to_vec());
Ok(Property { key, value })
}
}
@@ -187,7 +184,7 @@
#[derive(Debug, Default, AbiCoder)]
pub struct CollectionLimit {
field: CollectionLimitField,
- value: Option<uint256>,
+ value: Option<U256>,
}
impl CollectionLimit {
@@ -345,7 +342,7 @@
#[derive(Debug, Default, AbiCoder)]
pub struct TokenPropertyPermission {
/// Token property key.
- key: evm_coder::types::string,
+ key: evm_coder::types::String,
/// Token property permissions.
permissions: Vec<PropertyPermission>,
}
@@ -363,7 +360,7 @@
),
) -> Self {
let (key, permission) = value;
- let key = evm_coder::types::string::from_utf8(key.into_inner())
+ let key = evm_coder::types::String::from_utf8(key.into_inner())
.expect("Stored key must be valid");
let permissions = PropertyPermission::into_vec(permission);
Self { key, permissions }
@@ -393,12 +390,12 @@
#[derive(Debug, Default, AbiCoder)]
pub struct CollectionNesting {
token_owner: bool,
- ids: Vec<uint256>,
+ ids: Vec<U256>,
}
impl CollectionNesting {
/// Create [`CollectionNesting`].
- pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {
+ pub fn new(token_owner: bool, ids: Vec<U256>) -> Self {
Self { token_owner, ids }
}
}
@@ -416,3 +413,32 @@
Self { field, value }
}
}
+
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+#[derive(AbiCoder, Copy, Clone, Default, Debug)]
+#[repr(u8)]
+pub enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ #[default]
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList,
+}
+
+impl From<up_data_structs::AccessMode> for AccessMode {
+ fn from(value: up_data_structs::AccessMode) -> Self {
+ match value {
+ up_data_structs::AccessMode::Normal => AccessMode::Normal,
+ up_data_structs::AccessMode::AllowList => AccessMode::AllowList,
+ }
+ }
+}
+
+impl Into<up_data_structs::AccessMode> for AccessMode {
+ fn into(self) -> up_data_structs::AccessMode {
+ match self {
+ AccessMode::Normal => up_data_structs::AccessMode::Normal,
+ AccessMode::AllowList => up_data_structs::AccessMode::AllowList,
+ }
+ }
+}
pallets/evm-coder-substrate/src/lib.rsdiffbeforeafterboth--- a/pallets/evm-coder-substrate/src/lib.rs
+++ b/pallets/evm-coder-substrate/src/lib.rs
@@ -41,7 +41,7 @@
use evm_coder::{
abi::{AbiReader, AbiWrite, AbiWriter},
execution,
- types::{Msg, value},
+ types::{Msg, Value},
};
pub use pallet::*;
@@ -256,7 +256,7 @@
>(
caller: H160,
e: &mut E,
- value: value,
+ value: Value,
input: &[u8],
) -> execution::Result<Option<AbiWriter>> {
let (selector, mut reader) = AbiReader::new_call(input)?;
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))
}
@@ -105,10 +105,10 @@
/// @param sponsor User address who set as pending sponsor.
fn set_sponsor(
&mut self,
- caller: caller,
- contract_address: address,
- sponsor: address,
- ) -> Result<void> {
+ caller: Caller,
+ 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<void> {
+ 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<void> {
+ 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<void> {
+ 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,23 +194,23 @@
///
/// @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,
+ caller: Caller,
+ contract_address: Address,
mode: SponsoringModeT,
- ) -> Result<void> {
+ ) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -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<uint32> {
+ fn sponsoring_rate_limit(&self, contract_address: Address) -> Result<u32> {
self.recorder().consume_sload()?;
Ok(<SponsoringRateLimit<T>>::get(contract_address)
@@ -239,10 +239,10 @@
/// @dev Only contract owner can change this setting
fn set_sponsoring_rate_limit(
&mut self,
- caller: caller,
- contract_address: address,
- rate_limit: uint32,
- ) -> Result<void> {
+ caller: Caller,
+ contract_address: Address,
+ rate_limit: u32,
+ ) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -259,10 +259,10 @@
/// @dev Only contract owner can change this setting
fn set_sponsoring_fee_limit(
&mut self,
- caller: caller,
- contract_address: address,
- fee_limit: uint256,
- ) -> Result<void> {
+ caller: Caller,
+ contract_address: Address,
+ fee_limit: U256,
+ ) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -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<uint256> {
+ 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))
}
@@ -300,11 +300,11 @@
/// @dev Only contract owner can change this setting
fn toggle_allowed(
&mut self,
- caller: caller,
- contract_address: address,
- user: address,
+ caller: Caller,
+ contract_address: Address,
+ user: Address,
is_allowed: bool,
- ) -> Result<void> {
+ ) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -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))
}
@@ -329,10 +329,10 @@
/// @param enabled Should allowlist access to be enabled?
fn toggle_allowlist(
&mut self,
- caller: caller,
- contract_address: address,
+ caller: Caller,
+ contract_address: Address,
enabled: bool,
- ) -> Result<void> {
+ ) -> Result<()> {
self.recorder().consume_sload()?;
self.recorder().consume_sstore()?;
@@ -441,7 +441,7 @@
}
}
-fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> uint256 {
+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
@@ -32,7 +32,7 @@
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::{call, dispatch_to_evm};
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::Get;
+use sp_core::{U256, Get};
use crate::{
Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,
@@ -43,50 +43,50 @@
pub enum ERC20Events {
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
- value: uint256,
+ to: Address,
+ value: U256,
},
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- spender: address,
- value: uint256,
+ spender: Address,
+ value: U256,
},
}
#[solidity_interface(name = ERC20, events(ERC20Events))]
impl<T: Config> FungibleHandle<T> {
- fn name(&self) -> Result<string> {
+ fn name(&self) -> Result<String> {
Ok(decode_utf16(self.name.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
- fn symbol(&self) -> Result<string> {
- Ok(string::from_utf8_lossy(&self.token_prefix).into())
+ fn symbol(&self) -> Result<String> {
+ Ok(String::from_utf8_lossy(&self.token_prefix).into())
}
- fn total_supply(&self) -> Result<uint256> {
+ fn total_supply(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<TotalSupply<T>>::get(self.id).into())
}
- fn decimals(&self) -> Result<uint8> {
+ fn decimals(&self) -> Result<u8> {
Ok(if let CollectionMode::Fungible(decimals) = &self.mode {
*decimals
} else {
unreachable!()
})
}
- fn balance_of(&self, owner: address) -> Result<uint256> {
+ 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: uint256) -> 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")?;
@@ -101,10 +101,10 @@
#[weight(<SelfWeightOf<T>>::transfer_from())]
fn transfer_from(
&mut self,
- caller: caller,
- from: address,
- to: address,
- amount: uint256,
+ caller: Caller,
+ from: Address,
+ to: Address,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
@@ -119,7 +119,7 @@
Ok(true)
}
#[weight(<SelfWeightOf<T>>::approve())]
- fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> 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<uint256> {
+ 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: uint256) -> 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")?;
@@ -167,18 +167,18 @@
T::AccountId: From<[u8; 32]>,
{
/// @notice A description for the collection.
- fn description(&self) -> Result<string> {
+ fn description(&self) -> Result<String> {
Ok(decode_utf16(self.description.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
@@ -194,9 +194,9 @@
#[weight(<SelfWeightOf<T>>::approve())]
fn approve_cross(
&mut self,
- caller: caller,
+ caller: Caller,
spender: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let spender = spender.into_sub_cross_account::<T>()?;
@@ -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: uint256) -> 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")?;
@@ -235,9 +235,9 @@
#[weight(<SelfWeightOf<T>>::burn_from())]
fn burn_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
@@ -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, uint256)>) -> 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
@@ -277,9 +277,9 @@
#[weight(<SelfWeightOf<T>>::transfer())]
fn transfer_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
@@ -295,10 +295,10 @@
#[weight(<SelfWeightOf<T>>::transfer_from())]
fn transfer_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: pallet_common::eth::CrossAddress,
to: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
pallets/fungible/src/stubs/UniqueFungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/stubs/UniqueFungible.soldiffbeforeafterboth--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -274,11 +274,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) public {
+ function setCollectionAccess(AccessMode mode) public {
require(false, stub_error);
mode;
dummy = 0;
@@ -443,6 +441,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -43,7 +43,7 @@
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::call;
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::Get;
+use sp_core::{U256, Get};
use crate::{
AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,
@@ -63,8 +63,8 @@
#[solidity(hide)]
fn set_token_property_permission(
&mut self,
- caller: caller,
- key: string,
+ caller: Caller,
+ key: String,
is_mutable: bool,
collection_admin: bool,
token_owner: bool,
@@ -93,7 +93,7 @@
#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]
fn set_token_property_permissions(
&mut self,
- caller: caller,
+ caller: Caller,
permissions: Vec<eth::TokenPropertyPermission>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -121,10 +121,10 @@
#[weight(<SelfWeightOf<T>>::set_token_properties(1))]
fn set_property(
&mut self,
- caller: caller,
- token_id: uint256,
- key: string,
- value: bytes,
+ caller: Caller,
+ token_id: U256,
+ key: String,
+ value: Bytes,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -154,8 +154,8 @@
#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
fn set_properties(
&mut self,
- caller: caller,
- token_id: uint256,
+ caller: Caller,
+ token_id: U256,
properties: Vec<eth::Property>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -187,7 +187,7 @@
/// @param key Property key.
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
- fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
+ fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
let key = <Vec<u8>>::from(key)
@@ -209,9 +209,9 @@
#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
fn delete_properties(
&mut self,
- token_id: uint256,
- caller: caller,
- keys: Vec<string>,
+ token_id: U256,
+ caller: Caller,
+ keys: Vec<String>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -239,7 +239,7 @@
/// @param tokenId ID of the token.
/// @param key Property key.
/// @return Property value bytes
- fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
+ fn property(&self, token_id: U256, key: String) -> Result<Bytes> {
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
let key = <Vec<u8>>::from(key)
.try_into()
@@ -261,11 +261,11 @@
/// 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: uint256,
+ token_id: U256,
},
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
@@ -273,20 +273,20 @@
/// address for that NFT (if any) is reset to none.
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- approved: address,
+ approved: Address,
#[indexed]
- token_id: uint256,
+ token_id: U256,
},
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
#[allow(dead_code)]
ApprovalForAll {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- operator: address,
+ operator: Address,
approved: bool,
},
}
@@ -301,14 +301,14 @@
/// @notice A descriptive name for a collection of NFTs in this contract
/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
#[solidity(hide, rename_selector = "name")]
- fn name_proxy(&self) -> Result<string> {
+ fn name_proxy(&self) -> Result<String> {
self.name()
}
/// @notice An abbreviated name for NFTs in this contract
/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
#[solidity(hide, rename_selector = "symbol")]
- fn symbol_proxy(&self) -> Result<string> {
+ fn symbol_proxy(&self) -> Result<String> {
self.symbol()
}
@@ -322,7 +322,7 @@
///
/// @return token's const_metadata
#[solidity(rename_selector = "tokenURI")]
- fn token_uri(&self, token_id: uint256) -> Result<string> {
+ fn token_uri(&self, token_id: U256) -> Result<String> {
let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
match get_token_property(self, token_id_u32, &key::url()).as_deref() {
@@ -335,7 +335,7 @@
let base_uri =
pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())
.map(BoundedVec::into_inner)
- .map(string::from_utf8)
+ .map(String::from_utf8)
.transpose()
.map_err(|e| {
Error::Revert(alloc::format!(
@@ -368,12 +368,12 @@
/// @param index A counter less than `totalSupply()`
/// @return The token identifier for the `index`th NFT,
/// (sort order not specified)
- fn token_by_index(&self, index: uint256) -> Result<uint256> {
+ fn token_by_index(&self, index: U256) -> Result<U256> {
Ok(index)
}
/// @dev Not implemented
- fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
+ fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -381,7 +381,7 @@
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
- fn total_supply(&self) -> Result<uint256> {
+ fn total_supply(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<Pallet<T>>::total_supply(self).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<uint256> {
+ 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: uint256) -> 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,21 +419,16 @@
#[solidity(rename_selector = "safeTransferFrom")]
fn safe_transfer_from_with_data(
&mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- _data: bytes,
- ) -> Result<void> {
+ _from: Address,
+ _to: Address,
+ _token_id: U256,
+ _data: Bytes,
+ ) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
/// @dev Not implemented
- fn safe_transfer_from(
- &mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- ) -> Result<void> {
+ fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -450,11 +445,11 @@
#[weight(<SelfWeightOf<T>>::transfer_from())]
fn transfer_from(
&mut self,
- caller: caller,
- from: address,
- to: address,
- token_id: uint256,
- ) -> Result<void> {
+ caller: Caller,
+ from: Address,
+ to: Address,
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let to = T::CrossAccountId::from_eth(to);
@@ -475,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: uint256) -> Result<void> {
+ 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()?;
@@ -492,10 +487,10 @@
#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]
fn set_approval_for_all(
&mut self,
- caller: caller,
- operator: address,
+ caller: Caller,
+ operator: Address,
approved: bool,
- ) -> Result<void> {
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let operator = T::CrossAccountId::from_eth(operator);
@@ -505,14 +500,14 @@
}
/// @dev Not implemented
- fn get_approved(&self, _token_id: uint256) -> 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);
@@ -528,7 +523,7 @@
/// operator of the current owner.
/// @param tokenId The NFT to approve
#[weight(<SelfWeightOf<T>>::burn_item())]
- fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
+ fn burn(&mut self, caller: Caller, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token = token_id.try_into()?;
@@ -544,8 +539,8 @@
/// @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<uint256> {
- let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+ 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")?
.into();
@@ -560,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: uint256) -> 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()?;
@@ -598,11 +593,11 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_with_token_uri(
&mut self,
- caller: caller,
- to: address,
- token_uri: string,
- ) -> Result<uint256> {
- let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+ caller: Caller,
+ to: Address,
+ token_uri: String,
+ ) -> Result<U256> {
+ let token_id: U256 = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?
.into();
@@ -620,10 +615,10 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_with_token_uri_check_id(
&mut self,
- caller: caller,
- to: address,
- token_id: uint256,
- token_uri: string,
+ caller: Caller,
+ to: Address,
+ token_id: U256,
+ token_uri: String,
) -> Result<bool> {
let key = key::url();
let permission = get_token_permission::<T>(self.id, &key)?;
@@ -675,12 +670,12 @@
collection: &CollectionHandle<T>,
token_id: u32,
key: &up_data_structs::PropertyKey,
-) -> Result<string> {
+) -> Result<String> {
collection.consume_store_reads(1)?;
let properties = <TokenProperties<T>>::try_get((collection.id, token_id))
.map_err(|_| Error::Revert("Token properties not found".into()))?;
if let Some(property) = properties.get(key) {
- return Ok(string::from_utf8_lossy(property).into());
+ return Ok(String::from_utf8_lossy(property).into());
}
Err("Property tokenURI not found".into())
@@ -696,7 +691,7 @@
.get(key)
.map(Clone::clone)
.ok_or_else(|| {
- let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();
+ let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();
Error::Revert(alloc::format!("No permission for key {}", key))
})?;
Ok(a)
@@ -709,28 +704,28 @@
T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,
{
/// @notice A descriptive name for a collection of NFTs in this contract
- fn name(&self) -> Result<string> {
+ fn name(&self) -> Result<String> {
Ok(decode_utf16(self.name.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
/// @notice An abbreviated name for NFTs in this contract
- fn symbol(&self) -> Result<string> {
- Ok(string::from_utf8_lossy(&self.token_prefix).into())
+ fn symbol(&self) -> Result<String> {
+ Ok(String::from_utf8_lossy(&self.token_prefix).into())
}
/// @notice A description for the collection.
- fn description(&self) -> Result<string> {
+ fn description(&self) -> Result<String> {
Ok(decode_utf16(self.description.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
/// Returns the owner (in cross format) of the token.
///
/// @param tokenId Id for the token.
- fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
+ fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
Self::token_owner(&self, token_id.try_into()?)
.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
.ok_or(Error::Revert("key too large".into()))
@@ -741,7 +736,7 @@
/// @param tokenId Id for the token.
/// @param keys Properties keys. Empty keys for all propertyes.
/// @return Vector of properties key/value pairs.
- fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
+ fn properties(&self, token_id: U256, keys: Vec<String>) -> Result<Vec<eth::Property>> {
let keys = keys
.into_iter()
.map(|key| {
@@ -770,10 +765,10 @@
#[weight(<SelfWeightOf<T>>::approve())]
fn approve_cross(
&mut self,
- caller: caller,
+ caller: Caller,
approved: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let approved = approved.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
@@ -789,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: uint256) -> Result<void> {
+ 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()?;
@@ -809,10 +804,10 @@
#[weight(<SelfWeightOf<T>>::transfer())]
fn transfer_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
@@ -833,11 +828,11 @@
#[weight(<SelfWeightOf<T>>::transfer())]
fn transfer_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: eth::CrossAddress,
to: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let to = to.into_sub_cross_account::<T>()?;
@@ -858,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: uint256) -> Result<void> {
+ 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()?;
@@ -880,10 +875,10 @@
#[weight(<SelfWeightOf<T>>::burn_from())]
fn burn_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
@@ -897,7 +892,7 @@
}
/// @notice Returns next free NFT ID.
- fn next_token_id(&self) -> Result<uint256> {
+ fn next_token_id(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<TokensMinted<T>>::get(self.id)
.checked_add(1)
@@ -912,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<uint256>) -> 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)
@@ -951,9 +946,9 @@
#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
fn mint_bulk_with_token_uri(
&mut self,
- caller: caller,
- to: address,
- tokens: Vec<(uint256, string)>,
+ caller: Caller,
+ to: Address,
+ tokens: Vec<(U256, String)>,
) -> Result<bool> {
let key = key::url();
let caller = T::CrossAccountId::from_eth(caller);
@@ -1002,10 +997,10 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: eth::CrossAddress,
properties: Vec<eth::Property>,
- ) -> Result<uint256> {
+ ) -> Result<U256> {
let token_id = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?;
@@ -1040,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/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -416,11 +416,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) public {
+ function setCollectionAccess(AccessMode mode) public {
require(false, stub_error);
mode;
dummy = 0;
@@ -585,6 +583,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;
pallets/refungible/src/erc.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -39,7 +39,7 @@
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::{call, dispatch_to_evm};
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
-use sp_core::{H160, Get};
+use sp_core::{H160, U256, Get};
use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
use up_data_structs::{
CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,
@@ -66,8 +66,8 @@
#[solidity(hide)]
fn set_token_property_permission(
&mut self,
- caller: caller,
- key: string,
+ caller: Caller,
+ key: String,
is_mutable: bool,
collection_admin: bool,
token_owner: bool,
@@ -96,7 +96,7 @@
#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]
fn set_token_property_permissions(
&mut self,
- caller: caller,
+ caller: Caller,
permissions: Vec<eth::TokenPropertyPermission>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -124,10 +124,10 @@
#[weight(<SelfWeightOf<T>>::set_token_properties(1))]
fn set_property(
&mut self,
- caller: caller,
- token_id: uint256,
- key: string,
- value: bytes,
+ caller: Caller,
+ token_id: U256,
+ key: String,
+ value: Bytes,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -157,8 +157,8 @@
#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
fn set_properties(
&mut self,
- caller: caller,
- token_id: uint256,
+ caller: Caller,
+ token_id: U256,
properties: Vec<eth::Property>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -190,7 +190,7 @@
/// @param key Property key.
#[solidity(hide)]
#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
- fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
+ fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
let key = <Vec<u8>>::from(key)
@@ -212,9 +212,9 @@
#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
fn delete_properties(
&mut self,
- token_id: uint256,
- caller: caller,
- keys: Vec<string>,
+ token_id: U256,
+ caller: Caller,
+ keys: Vec<String>,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -242,7 +242,7 @@
/// @param tokenId ID of the token.
/// @param key Property key.
/// @return Property value bytes
- fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
+ fn property(&self, token_id: U256, key: String) -> Result<Bytes> {
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
let key = <Vec<u8>>::from(key)
.try_into()
@@ -262,28 +262,28 @@
/// may be created and assigned without emitting Transfer.
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
+ to: Address,
#[indexed]
- token_id: uint256,
+ token_id: U256,
},
/// @dev Not supported
Approval {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- approved: address,
+ approved: Address,
#[indexed]
- token_id: uint256,
+ token_id: U256,
},
/// @dev Not supported
#[allow(dead_code)]
ApprovalForAll {
#[indexed]
- owner: address,
+ owner: Address,
#[indexed]
- operator: address,
+ operator: Address,
approved: bool,
},
}
@@ -298,14 +298,14 @@
/// @notice A descriptive name for a collection of NFTs in this contract
/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
#[solidity(hide, rename_selector = "name")]
- fn name_proxy(&self) -> Result<string> {
+ fn name_proxy(&self) -> Result<String> {
self.name()
}
/// @notice An abbreviated name for NFTs in this contract
/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
#[solidity(hide, rename_selector = "symbol")]
- fn symbol_proxy(&self) -> Result<string> {
+ fn symbol_proxy(&self) -> Result<String> {
self.symbol()
}
@@ -319,7 +319,7 @@
///
/// @return token's const_metadata
#[solidity(rename_selector = "tokenURI")]
- fn token_uri(&self, token_id: uint256) -> Result<string> {
+ fn token_uri(&self, token_id: U256) -> Result<String> {
let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
match get_token_property(self, token_id_u32, &key::url()).as_deref() {
@@ -332,7 +332,7 @@
let base_uri =
pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())
.map(BoundedVec::into_inner)
- .map(string::from_utf8)
+ .map(String::from_utf8)
.transpose()
.map_err(|e| {
Error::Revert(alloc::format!(
@@ -365,12 +365,12 @@
/// @param index A counter less than `totalSupply()`
/// @return The token identifier for the `index`th NFT,
/// (sort order not specified)
- fn token_by_index(&self, index: uint256) -> Result<uint256> {
+ fn token_by_index(&self, index: U256) -> Result<U256> {
Ok(index)
}
/// Not implemented
- fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
+ fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -378,7 +378,7 @@
/// @notice Count RFTs tracked by this contract
/// @return A count of valid RFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
- fn total_supply(&self) -> Result<uint256> {
+ fn total_supply(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<Pallet<T>>::total_supply(self).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<uint256> {
+ 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: uint256) -> 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,23 +420,18 @@
#[solidity(rename_selector = "safeTransferFrom")]
fn safe_transfer_from_with_data(
&mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- _data: bytes,
- ) -> Result<void> {
+ _from: Address,
+ _to: Address,
+ _token_id: U256,
+ _data: Bytes,
+ ) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
/// @dev Not implemented
#[solidity(rename_selector = "safeTransferFrom")]
- fn safe_transfer_from(
- &mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- ) -> Result<void> {
+ fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
// TODO: Not implemetable
Err("not implemented".into())
}
@@ -454,11 +449,11 @@
#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]
fn transfer_from(
&mut self,
- caller: caller,
- from: address,
- to: address,
- token_id: uint256,
- ) -> Result<void> {
+ caller: Caller,
+ from: Address,
+ to: Address,
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let to = T::CrossAccountId::from_eth(to);
@@ -477,7 +472,7 @@
}
/// @dev Not implemented
- fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {
+ fn approve(&mut self, _caller: Caller, _approved: Address, _token_id: U256) -> Result<()> {
Err("not implemented".into())
}
@@ -488,10 +483,10 @@
#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]
fn set_approval_for_all(
&mut self,
- caller: caller,
- operator: address,
+ caller: Caller,
+ operator: Address,
approved: bool,
- ) -> Result<void> {
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let operator = T::CrossAccountId::from_eth(operator);
@@ -501,14 +496,14 @@
}
/// @dev Not implemented
- fn get_approved(&self, _token_id: uint256) -> 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);
@@ -556,7 +551,7 @@
/// operator of the current owner.
/// @param tokenId The RFT to approve
#[weight(<SelfWeightOf<T>>::burn_item_fully())]
- fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
+ fn burn(&mut self, caller: Caller, token_id: U256) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token = token_id.try_into()?;
@@ -575,8 +570,8 @@
/// @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<uint256> {
- let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+ 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")?
.into();
@@ -591,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: uint256) -> 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()?;
@@ -634,11 +629,11 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_with_token_uri(
&mut self,
- caller: caller,
- to: address,
- token_uri: string,
- ) -> Result<uint256> {
- let token_id: uint256 = <TokensMinted<T>>::get(self.id)
+ caller: Caller,
+ to: Address,
+ token_uri: String,
+ ) -> Result<U256> {
+ let token_id: U256 = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?
.into();
@@ -656,10 +651,10 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_with_token_uri_check_id(
&mut self,
- caller: caller,
- to: address,
- token_id: uint256,
- token_uri: string,
+ caller: Caller,
+ to: Address,
+ token_id: U256,
+ token_uri: String,
) -> Result<bool> {
let key = key::url();
let permission = get_token_permission::<T>(self.id, &key)?;
@@ -713,12 +708,12 @@
collection: &CollectionHandle<T>,
token_id: u32,
key: &up_data_structs::PropertyKey,
-) -> Result<string> {
+) -> Result<String> {
collection.consume_store_reads(1)?;
let properties = <TokenProperties<T>>::try_get((collection.id, token_id))
.map_err(|_| Error::Revert("Token properties not found".into()))?;
if let Some(property) = properties.get(key) {
- return Ok(string::from_utf8_lossy(property).into());
+ return Ok(String::from_utf8_lossy(property).into());
}
Err("Property tokenURI not found".into())
@@ -734,7 +729,7 @@
.get(key)
.map(Clone::clone)
.ok_or_else(|| {
- let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();
+ let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();
Error::Revert(alloc::format!("No permission for key {}", key))
})?;
Ok(a)
@@ -747,28 +742,28 @@
T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,
{
/// @notice A descriptive name for a collection of NFTs in this contract
- fn name(&self) -> Result<string> {
+ fn name(&self) -> Result<String> {
Ok(decode_utf16(self.name.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
/// @notice An abbreviated name for NFTs in this contract
- fn symbol(&self) -> Result<string> {
- Ok(string::from_utf8_lossy(&self.token_prefix).into())
+ fn symbol(&self) -> Result<String> {
+ Ok(String::from_utf8_lossy(&self.token_prefix).into())
}
/// @notice A description for the collection.
- fn description(&self) -> Result<string> {
+ fn description(&self) -> Result<String> {
Ok(decode_utf16(self.description.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
/// Returns the owner (in cross format) of the token.
///
/// @param tokenId Id for the token.
- fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
+ fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
Self::token_owner(&self, token_id.try_into()?)
.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
.ok_or(Error::Revert("key too large".into()))
@@ -779,7 +774,7 @@
/// @param tokenId Id for the token.
/// @param keys Properties keys. Empty keys for all propertyes.
/// @return Vector of properties key/value pairs.
- fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
+ fn properties(&self, token_id: U256, keys: Vec<String>) -> Result<Vec<eth::Property>> {
let keys = keys
.into_iter()
.map(|key| {
@@ -805,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: uint256) -> Result<void> {
+ 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()?;
@@ -830,10 +825,10 @@
#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
fn transfer_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
@@ -858,11 +853,11 @@
#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
fn transfer_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: eth::CrossAddress,
to: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let to = to.into_sub_cross_account::<T>()?;
@@ -888,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: uint256) -> Result<void> {
+ 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()?;
@@ -914,10 +909,10 @@
#[weight(<SelfWeightOf<T>>::burn_from())]
fn burn_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: eth::CrossAddress,
- token_id: uint256,
- ) -> Result<void> {
+ token_id: U256,
+ ) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
@@ -934,7 +929,7 @@
}
/// @notice Returns next free RFT ID.
- fn next_token_id(&self) -> Result<uint256> {
+ fn next_token_id(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<TokensMinted<T>>::get(self.id)
.checked_add(1)
@@ -949,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<uint256>) -> 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)
@@ -994,9 +989,9 @@
#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
fn mint_bulk_with_token_uri(
&mut self,
- caller: caller,
- to: address,
- tokens: Vec<(uint256, string)>,
+ caller: Caller,
+ to: Address,
+ tokens: Vec<(U256, String)>,
) -> Result<bool> {
let key = key::url();
let caller = T::CrossAccountId::from_eth(caller);
@@ -1051,10 +1046,10 @@
#[weight(<SelfWeightOf<T>>::create_item())]
fn mint_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: eth::CrossAddress,
properties: Vec<eth::Property>,
- ) -> Result<uint256> {
+ ) -> Result<U256> {
let token_id = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?;
@@ -1093,7 +1088,7 @@
/// Returns EVM address for refungible token
///
/// @param token ID of the token
- fn token_contract_address(&self, token: uint256) -> 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")?,
@@ -1101,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
@@ -37,6 +37,7 @@
use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};
use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
use sp_std::vec::Vec;
+use sp_core::U256;
use up_data_structs::TokenId;
use crate::{
@@ -51,11 +52,11 @@
#[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))
}
- fn parent_token_id(&self) -> Result<uint256> {
+ fn parent_token_id(&self) -> Result<U256> {
Ok(self.1.into())
}
}
@@ -68,19 +69,19 @@
/// of burning tokens the transfer is to 0.
Transfer {
#[indexed]
- from: address,
+ from: Address,
#[indexed]
- to: address,
- value: uint256,
+ 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,
- value: uint256,
+ spender: Address,
+ value: U256,
},
}
@@ -91,25 +92,25 @@
#[solidity_interface(name = ERC20, events(ERC20Events))]
impl<T: Config> RefungibleTokenHandle<T> {
/// @return the name of the token.
- fn name(&self) -> Result<string> {
+ fn name(&self) -> Result<String> {
Ok(decode_utf16(self.name.iter().copied())
.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
+ .collect::<String>())
}
/// @return the symbol of the token.
- fn symbol(&self) -> Result<string> {
- Ok(string::from_utf8_lossy(&self.token_prefix).into())
+ fn symbol(&self) -> Result<String> {
+ Ok(String::from_utf8_lossy(&self.token_prefix).into())
}
/// @dev Total number of tokens in existence
- fn total_supply(&self) -> Result<uint256> {
+ fn total_supply(&self) -> Result<U256> {
self.consume_store_reads(1)?;
Ok(<TotalSupply<T>>::get((self.id, self.1)).into())
}
/// @dev Not supported
- fn decimals(&self) -> Result<uint8> {
+ fn decimals(&self) -> Result<u8> {
// Decimals aren't supported for refungible tokens
Ok(0)
}
@@ -117,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<uint256> {
+ 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));
@@ -128,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: uint256) -> 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")?;
@@ -148,10 +149,10 @@
#[weight(<CommonWeights<T>>::transfer_from())]
fn transfer_from(
&mut self,
- caller: caller,
- from: address,
- to: address,
- amount: uint256,
+ caller: Caller,
+ from: Address,
+ to: Address,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
@@ -174,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: uint256) -> 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")?;
@@ -188,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<uint256> {
+ 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);
@@ -208,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: uint256) -> 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")?;
@@ -228,9 +229,9 @@
#[weight(<SelfWeightOf<T>>::burn_from())]
fn burn_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
@@ -254,9 +255,9 @@
#[weight(<SelfWeightOf<T>>::approve())]
fn approve_cross(
&mut self,
- caller: caller,
+ caller: Caller,
spender: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let spender = spender.into_sub_cross_account::<T>()?;
@@ -270,7 +271,7 @@
/// Throws if `msg.sender` doesn't owns all of the tokens.
/// @param amount New total amount of the tokens.
#[weight(<SelfWeightOf<T>>::repartition_item())]
- fn repartition(&mut self, caller: caller, amount: uint256) -> Result<bool> {
+ fn repartition(&mut self, caller: Caller, amount: U256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -284,9 +285,9 @@
#[weight(<CommonWeights<T>>::transfer())]
fn transfer_cross(
&mut self,
- caller: caller,
+ caller: Caller,
to: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
@@ -307,10 +308,10 @@
#[weight(<CommonWeights<T>>::transfer_from())]
fn transfer_from_cross(
&mut self,
- caller: caller,
+ caller: Caller,
from: pallet_common::eth::CrossAddress,
to: pallet_common::eth::CrossAddress,
- amount: uint256,
+ amount: U256,
) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
pallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungible.soldiffbeforeafterboth--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.sol
@@ -416,11 +416,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) public {
+ function setCollectionAccess(AccessMode mode) public {
require(false, stub_error);
mode;
dummy = 0;
@@ -585,6 +583,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;
pallets/unique/src/eth/mod.rsdiffbeforeafterboth--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -56,10 +56,10 @@
}
fn convert_data<T: Config>(
- caller: caller,
- name: string,
- description: string,
- token_prefix: string,
+ caller: Caller,
+ name: String,
+ description: String,
+ token_prefix: String,
) -> Result<(
T::CrossAccountId,
CollectionName,
@@ -87,13 +87,13 @@
#[inline(always)]
fn create_collection_internal<T: Config>(
- caller: caller,
- value: value,
- name: string,
+ caller: Caller,
+ value: Value,
+ name: String,
collection_mode: CollectionMode,
- description: string,
- token_prefix: string,
-) -> Result<address> {
+ description: String,
+ token_prefix: String,
+) -> Result<Address> {
let (caller, name, description, token_prefix) =
convert_data::<T>(caller, name, description, token_prefix)?;
let data = CreateCollectionData {
@@ -118,7 +118,7 @@
Ok(address)
}
-fn check_sent_amount_equals_collection_creation_price<T: Config>(value: value) -> Result<()> {
+fn check_sent_amount_equals_collection_creation_price<T: Config>(value: Value) -> Result<()> {
let value = value.as_u128();
let creation_price: u128 = T::CollectionCreationPrice::get()
.try_into()
@@ -149,12 +149,12 @@
#[solidity(rename_selector = "createNFTCollection")]
fn create_nft_collection(
&mut self,
- caller: caller,
- value: value,
- name: string,
- description: string,
- token_prefix: string,
- ) -> Result<address> {
+ caller: Caller,
+ value: Value,
+ name: String,
+ description: String,
+ token_prefix: String,
+ ) -> Result<Address> {
let (caller, name, description, token_prefix) =
convert_data::<T>(caller, name, description, token_prefix)?;
let data = CreateCollectionData {
@@ -188,12 +188,12 @@
#[solidity(hide)]
fn create_nonfungible_collection(
&mut self,
- caller: caller,
- value: value,
- name: string,
- description: string,
- token_prefix: string,
- ) -> Result<address> {
+ caller: Caller,
+ value: Value,
+ name: String,
+ description: String,
+ token_prefix: String,
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -208,12 +208,12 @@
#[solidity(rename_selector = "createRFTCollection")]
fn create_rft_collection(
&mut self,
- caller: caller,
- value: value,
- name: string,
- description: string,
- token_prefix: string,
- ) -> Result<address> {
+ caller: Caller,
+ value: Value,
+ name: String,
+ description: String,
+ token_prefix: String,
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -228,13 +228,13 @@
#[solidity(rename_selector = "createFTCollection")]
fn create_fungible_collection(
&mut self,
- caller: caller,
- value: value,
- name: string,
- decimals: uint8,
- description: string,
- token_prefix: string,
- ) -> Result<address> {
+ caller: Caller,
+ value: Value,
+ name: String,
+ decimals: u8,
+ description: String,
+ token_prefix: String,
+ ) -> Result<Address> {
create_collection_internal::<T>(
caller,
value,
@@ -248,9 +248,9 @@
#[solidity(rename_selector = "makeCollectionERC721MetadataCompatible")]
fn make_collection_metadata_compatible(
&mut self,
- caller: caller,
- collection: address,
- base_uri: string,
+ caller: Caller,
+ collection: Address,
+ base_uri: String,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let collection =
@@ -334,7 +334,7 @@
}
#[weight(<SelfWeightOf<T>>::destroy_collection())]
- fn destroy_collection(&mut self, caller: caller, collection_address: address) -> Result<void> {
+ 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));
@@ -355,7 +355,7 @@
Ok(false)
}
- fn collection_creation_fee(&self) -> Result<value> {
+ fn collection_creation_fee(&self) -> Result<Value> {
let price: u128 = T::CollectionCreationPrice::get()
.try_into()
.map_err(|_| ()) // workaround for `expect` requiring `Debug` trait
@@ -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: uint32) -> 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<uint32> {
+ fn collection_id(&self, collection_address: Address) -> Result<u32> {
map_eth_to_id(&collection_address)
.map(|id| id.0)
.ok_or(Error::Revert(format!(
runtime/tests/src/tests.rsdiffbeforeafterboth--- a/runtime/tests/src/tests.rs
+++ b/runtime/tests/src/tests.rs
@@ -323,7 +323,7 @@
.map(|d| { d.into() })
.collect()
));
- for (index, data) in items_data.into_iter().enumerate() {
+ for (index, _data) in items_data.into_iter().enumerate() {
let balance = <pallet_refungible::Balance<Test>>::get((
CollectionId(1),
TokenId((index + 1) as u32),
tests/src/eth/abi/fungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/fungible.json
+++ b/tests/src/eth/abi/fungible.json
@@ -488,7 +488,9 @@
"type": "function"
},
{
- "inputs": [{ "internalType": "uint8", "name": "mode", "type": "uint8" }],
+ "inputs": [
+ { "internalType": "enum AccessMode", "name": "mode", "type": "uint8" }
+ ],
"name": "setCollectionAccess",
"outputs": [],
"stateMutability": "nonpayable",
tests/src/eth/abi/nonFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -630,7 +630,9 @@
"type": "function"
},
{
- "inputs": [{ "internalType": "uint8", "name": "mode", "type": "uint8" }],
+ "inputs": [
+ { "internalType": "enum AccessMode", "name": "mode", "type": "uint8" }
+ ],
"name": "setCollectionAccess",
"outputs": [],
"stateMutability": "nonpayable",
tests/src/eth/abi/reFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -612,7 +612,9 @@
"type": "function"
},
{
- "inputs": [{ "internalType": "uint8", "name": "mode", "type": "uint8" }],
+ "inputs": [
+ { "internalType": "enum AccessMode", "name": "mode", "type": "uint8" }
+ ],
"name": "setCollectionAccess",
"outputs": [],
"stateMutability": "nonpayable",
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -175,11 +175,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) external;
+ function setCollectionAccess(AccessMode mode) external;
/// Checks that user allowed to operate with collection.
///
@@ -285,6 +283,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -275,11 +275,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) external;
+ function setCollectionAccess(AccessMode mode) external;
/// Checks that user allowed to operate with collection.
///
@@ -385,6 +383,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;
tests/src/eth/api/UniqueRefungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -275,11 +275,9 @@
/// Set the collection access method.
/// @param mode Access mode
- /// 0 for Normal
- /// 1 for AllowList
/// @dev EVM selector for this function is: 0x41835d4c,
/// or in textual repr: setCollectionAccess(uint8)
- function setCollectionAccess(uint8 mode) external;
+ function setCollectionAccess(AccessMode mode) external;
/// Checks that user allowed to operate with collection.
///
@@ -385,6 +383,14 @@
uint256 sub;
}
+/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).
+enum AccessMode {
+ /// Access grant for owner and admins. Used as default.
+ Normal,
+ /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.
+ AllowList
+}
+
/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.
struct CollectionNestingPermission {
CollectionPermissionField field;