difftreelog
added cross methods: `burnFromCross` , `transferCross`, `approveCorss` in `ERC20` refungible pallet interface
in: master
5 files changed
pallets/refungible/src/erc_token.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Refungible Pallet EVM API for token pieces18//!19//! Provides ERC-20 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.2122extern crate alloc;2324#[cfg(not(feature = "std"))]25use alloc::format;2627use core::{28 char::{REPLACEMENT_CHARACTER, decode_utf16},29 convert::TryInto,30 ops::Deref,31};32use evm_coder::{33 abi::AbiType, ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight,34};35use pallet_common::{36 CommonWeightInfo,37 erc::{CommonEvmHandler, PrecompileResult},38 eth::collection_id_to_address,39};40use pallet_evm::{account::CrossAccountId, PrecompileHandle};41use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};42use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};43use sp_std::vec::Vec;44use up_data_structs::TokenId;4546use crate::{47 Allowance, Balance, common::CommonWeights, Config, Pallet, RefungibleHandle, SelfWeightOf,48 TotalSupply, weights::WeightInfo,49};5051pub struct RefungibleTokenHandle<T: Config>(pub RefungibleHandle<T>, pub TokenId);5253#[solidity_interface(name = ERC1633)]54impl<T: Config> RefungibleTokenHandle<T> {55 fn parent_token(&self) -> Result<address> {56 Ok(collection_id_to_address(self.id))57 }5859 fn parent_token_id(&self) -> Result<uint256> {60 Ok(self.1.into())61 }62}6364#[derive(ToLog)]65pub enum ERC20Events {66 /// @dev This event is emitted when the amount of tokens (value) is sent67 /// from the from address to the to address. In the case of minting new68 /// tokens, the transfer is usually from the 0 address while in the case69 /// of burning tokens the transfer is to 0.70 Transfer {71 #[indexed]72 from: address,73 #[indexed]74 to: address,75 value: uint256,76 },77 /// @dev This event is emitted when the amount of tokens (value) is approved78 /// by the owner to be used by the spender.79 Approval {80 #[indexed]81 owner: address,82 #[indexed]83 spender: address,84 value: uint256,85 },86}8788/// @title Standard ERC20 token89///90/// @dev Implementation of the basic standard token.91/// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md92#[solidity_interface(name = ERC20, events(ERC20Events))]93impl<T: Config> RefungibleTokenHandle<T> {94 /// @return the name of the token.95 fn name(&self) -> Result<string> {96 Ok(decode_utf16(self.name.iter().copied())97 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))98 .collect::<string>())99 }100101 /// @return the symbol of the token.102 fn symbol(&self) -> Result<string> {103 Ok(string::from_utf8_lossy(&self.token_prefix).into())104 }105106 /// @dev Total number of tokens in existence107 fn total_supply(&self) -> Result<uint256> {108 self.consume_store_reads(1)?;109 Ok(<TotalSupply<T>>::get((self.id, self.1)).into())110 }111112 /// @dev Not supported113 fn decimals(&self) -> Result<uint8> {114 // Decimals aren't supported for refungible tokens115 Ok(0)116 }117118 /// @dev Gets the balance of the specified address.119 /// @param owner The address to query the balance of.120 /// @return An uint256 representing the amount owned by the passed address.121 fn balance_of(&self, owner: address) -> Result<uint256> {122 self.consume_store_reads(1)?;123 let owner = T::CrossAccountId::from_eth(owner);124 let balance = <Balance<T>>::get((self.id, self.1, owner));125 Ok(balance.into())126 }127128 /// @dev Transfer token for a specified address129 /// @param to The address to transfer to.130 /// @param amount The amount to be transferred.131 #[weight(<CommonWeights<T>>::transfer())]132 fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {133 let caller = T::CrossAccountId::from_eth(caller);134 let to = T::CrossAccountId::from_eth(to);135 let amount = amount.try_into().map_err(|_| "amount overflow")?;136 let budget = self137 .recorder138 .weight_calls_budget(<StructureWeight<T>>::find_parent());139140 <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)141 .map_err(dispatch_to_evm::<T>)?;142 Ok(true)143 }144145 /// @dev Transfer tokens from one address to another146 /// @param from address The address which you want to send tokens from147 /// @param to address The address which you want to transfer to148 /// @param amount uint256 the amount of tokens to be transferred149 #[weight(<CommonWeights<T>>::transfer_from())]150 fn transfer_from(151 &mut self,152 caller: caller,153 from: address,154 to: address,155 amount: uint256,156 ) -> Result<bool> {157 let caller = T::CrossAccountId::from_eth(caller);158 let from = T::CrossAccountId::from_eth(from);159 let to = T::CrossAccountId::from_eth(to);160 let amount = amount.try_into().map_err(|_| "amount overflow")?;161 let budget = self162 .recorder163 .weight_calls_budget(<StructureWeight<T>>::find_parent());164165 <Pallet<T>>::transfer_from(self, &caller, &from, &to, self.1, amount, &budget)166 .map_err(dispatch_to_evm::<T>)?;167 Ok(true)168 }169170 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.171 /// Beware that changing an allowance with this method brings the risk that someone may use both the old172 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this173 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:174 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729175 /// @param spender The address which will spend the funds.176 /// @param amount The amount of tokens to be spent.177 #[weight(<SelfWeightOf<T>>::approve())]178 fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {179 let caller = T::CrossAccountId::from_eth(caller);180 let spender = T::CrossAccountId::from_eth(spender);181 let amount = amount.try_into().map_err(|_| "amount overflow")?;182183 <Pallet<T>>::set_allowance(self, &caller, &spender, self.1, amount)184 .map_err(dispatch_to_evm::<T>)?;185 Ok(true)186 }187188 /// @dev Function to check the amount of tokens that an owner allowed to a spender.189 /// @param owner address The address which owns the funds.190 /// @param spender address The address which will spend the funds.191 /// @return A uint256 specifying the amount of tokens still available for the spender.192 fn allowance(&self, owner: address, spender: address) -> Result<uint256> {193 self.consume_store_reads(1)?;194 let owner = T::CrossAccountId::from_eth(owner);195 let spender = T::CrossAccountId::from_eth(spender);196197 Ok(<Allowance<T>>::get((self.id, self.1, owner, spender)).into())198 }199}200201#[solidity_interface(name = ERC20UniqueExtensions)]202impl<T: Config> RefungibleTokenHandle<T> {203 /// @dev Function that burns an amount of the token of a given account,204 /// deducting from the sender's allowance for said account.205 /// @param from The account whose tokens will be burnt.206 /// @param amount The amount that will be burnt.207 #[weight(<SelfWeightOf<T>>::burn_from())]208 fn burn_from(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {209 let caller = T::CrossAccountId::from_eth(caller);210 let from = T::CrossAccountId::from_eth(from);211 let amount = amount.try_into().map_err(|_| "amount overflow")?;212 let budget = self213 .recorder214 .weight_calls_budget(<StructureWeight<T>>::find_parent());215216 <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)217 .map_err(dispatch_to_evm::<T>)?;218 Ok(true)219 }220221 /// @dev Function that changes total amount of the tokens.222 /// Throws if `msg.sender` doesn't owns all of the tokens.223 /// @param amount New total amount of the tokens.224 #[weight(<SelfWeightOf<T>>::repartition_item())]225 fn repartition(&mut self, caller: caller, amount: uint256) -> Result<bool> {226 let caller = T::CrossAccountId::from_eth(caller);227 let amount = amount.try_into().map_err(|_| "amount overflow")?;228229 <Pallet<T>>::repartition(self, &caller, self.1, amount).map_err(dispatch_to_evm::<T>)?;230 Ok(true)231 }232}233234impl<T: Config> RefungibleTokenHandle<T> {235 pub fn into_inner(self) -> RefungibleHandle<T> {236 self.0237 }238 pub fn common_mut(&mut self) -> &mut RefungibleHandle<T> {239 &mut self.0240 }241}242243impl<T: Config> WithRecorder<T> for RefungibleTokenHandle<T> {244 fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {245 self.0.recorder()246 }247 fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {248 self.0.into_recorder()249 }250}251252impl<T: Config> Deref for RefungibleTokenHandle<T> {253 type Target = RefungibleHandle<T>;254255 fn deref(&self) -> &Self::Target {256 &self.0257 }258}259260#[solidity_interface(261 name = UniqueRefungibleToken,262 is(ERC20, ERC20UniqueExtensions, ERC1633)263)]264impl<T: Config> RefungibleTokenHandle<T> where T::AccountId: From<[u8; 32]> {}265266generate_stubgen!(gen_impl, UniqueRefungibleTokenCall<()>, true);267generate_stubgen!(gen_iface, UniqueRefungibleTokenCall<()>, false);268269impl<T: Config> CommonEvmHandler for RefungibleTokenHandle<T>270where271 T::AccountId: From<[u8; 32]>,272{273 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungibleToken.raw");274275 fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {276 call::<T, UniqueRefungibleTokenCall<T>, _, _>(handle, self)277 }278}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Refungible Pallet EVM API for token pieces18//!19//! Provides ERC-20 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.2122extern crate alloc;2324#[cfg(not(feature = "std"))]25use alloc::format;2627use core::{28 char::{REPLACEMENT_CHARACTER, decode_utf16},29 convert::TryInto,30 ops::Deref,31};32use evm_coder::{33 abi::AbiType, ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight,34};35use pallet_common::{36 CommonWeightInfo,37 erc::{CommonEvmHandler, PrecompileResult},38 eth::{collection_id_to_address, EthCrossAccount},39};40use pallet_evm::{account::CrossAccountId, PrecompileHandle};41use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};42use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};43use sp_std::vec::Vec;44use up_data_structs::TokenId;4546use crate::{47 Allowance, Balance, common::CommonWeights, Config, Pallet, RefungibleHandle, SelfWeightOf,48 TotalSupply, weights::WeightInfo,49};5051pub struct RefungibleTokenHandle<T: Config>(pub RefungibleHandle<T>, pub TokenId);5253#[solidity_interface(name = ERC1633)]54impl<T: Config> RefungibleTokenHandle<T> {55 fn parent_token(&self) -> Result<address> {56 Ok(collection_id_to_address(self.id))57 }5859 fn parent_token_id(&self) -> Result<uint256> {60 Ok(self.1.into())61 }62}6364#[derive(ToLog)]65pub enum ERC20Events {66 /// @dev This event is emitted when the amount of tokens (value) is sent67 /// from the from address to the to address. In the case of minting new68 /// tokens, the transfer is usually from the 0 address while in the case69 /// of burning tokens the transfer is to 0.70 Transfer {71 #[indexed]72 from: address,73 #[indexed]74 to: address,75 value: uint256,76 },77 /// @dev This event is emitted when the amount of tokens (value) is approved78 /// by the owner to be used by the spender.79 Approval {80 #[indexed]81 owner: address,82 #[indexed]83 spender: address,84 value: uint256,85 },86}8788/// @title Standard ERC20 token89///90/// @dev Implementation of the basic standard token.91/// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md92#[solidity_interface(name = ERC20, events(ERC20Events))]93impl<T: Config> RefungibleTokenHandle<T> {94 /// @return the name of the token.95 fn name(&self) -> Result<string> {96 Ok(decode_utf16(self.name.iter().copied())97 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))98 .collect::<string>())99 }100101 /// @return the symbol of the token.102 fn symbol(&self) -> Result<string> {103 Ok(string::from_utf8_lossy(&self.token_prefix).into())104 }105106 /// @dev Total number of tokens in existence107 fn total_supply(&self) -> Result<uint256> {108 self.consume_store_reads(1)?;109 Ok(<TotalSupply<T>>::get((self.id, self.1)).into())110 }111112 /// @dev Not supported113 fn decimals(&self) -> Result<uint8> {114 // Decimals aren't supported for refungible tokens115 Ok(0)116 }117118 /// @dev Gets the balance of the specified address.119 /// @param owner The address to query the balance of.120 /// @return An uint256 representing the amount owned by the passed address.121 fn balance_of(&self, owner: address) -> Result<uint256> {122 self.consume_store_reads(1)?;123 let owner = T::CrossAccountId::from_eth(owner);124 let balance = <Balance<T>>::get((self.id, self.1, owner));125 Ok(balance.into())126 }127128 /// @dev Transfer token for a specified address129 /// @param to The address to transfer to.130 /// @param amount The amount to be transferred.131 #[weight(<CommonWeights<T>>::transfer())]132 fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {133 let caller = T::CrossAccountId::from_eth(caller);134 let to = T::CrossAccountId::from_eth(to);135 let amount = amount.try_into().map_err(|_| "amount overflow")?;136 let budget = self137 .recorder138 .weight_calls_budget(<StructureWeight<T>>::find_parent());139140 <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)141 .map_err(dispatch_to_evm::<T>)?;142 Ok(true)143 }144145 /// @dev Transfer tokens from one address to another146 /// @param from address The address which you want to send tokens from147 /// @param to address The address which you want to transfer to148 /// @param amount uint256 the amount of tokens to be transferred149 #[weight(<CommonWeights<T>>::transfer_from())]150 fn transfer_from(151 &mut self,152 caller: caller,153 from: address,154 to: address,155 amount: uint256,156 ) -> Result<bool> {157 let caller = T::CrossAccountId::from_eth(caller);158 let from = T::CrossAccountId::from_eth(from);159 let to = T::CrossAccountId::from_eth(to);160 let amount = amount.try_into().map_err(|_| "amount overflow")?;161 let budget = self162 .recorder163 .weight_calls_budget(<StructureWeight<T>>::find_parent());164165 <Pallet<T>>::transfer_from(self, &caller, &from, &to, self.1, amount, &budget)166 .map_err(dispatch_to_evm::<T>)?;167 Ok(true)168 }169170 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.171 /// Beware that changing an allowance with this method brings the risk that someone may use both the old172 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this173 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:174 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729175 /// @param spender The address which will spend the funds.176 /// @param amount The amount of tokens to be spent.177 #[weight(<SelfWeightOf<T>>::approve())]178 fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {179 let caller = T::CrossAccountId::from_eth(caller);180 let spender = T::CrossAccountId::from_eth(spender);181 let amount = amount.try_into().map_err(|_| "amount overflow")?;182183 <Pallet<T>>::set_allowance(self, &caller, &spender, self.1, amount)184 .map_err(dispatch_to_evm::<T>)?;185 Ok(true)186 }187188 /// @dev Function to check the amount of tokens that an owner allowed to a spender.189 /// @param owner address The address which owns the funds.190 /// @param spender address The address which will spend the funds.191 /// @return A uint256 specifying the amount of tokens still available for the spender.192 fn allowance(&self, owner: address, spender: address) -> Result<uint256> {193 self.consume_store_reads(1)?;194 let owner = T::CrossAccountId::from_eth(owner);195 let spender = T::CrossAccountId::from_eth(spender);196197 Ok(<Allowance<T>>::get((self.id, self.1, owner, spender)).into())198 }199}200201#[solidity_interface(name = ERC20UniqueExtensions)]202impl<T: Config> RefungibleTokenHandle<T>203where204 T::AccountId: From<[u8; 32]>,205{206 /// @dev Function that burns an amount of the token of a given account,207 /// deducting from the sender's allowance for said account.208 /// @param from The account whose tokens will be burnt.209 /// @param amount The amount that will be burnt.210 #[weight(<SelfWeightOf<T>>::burn_from())]211 fn burn_from(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {212 let caller = T::CrossAccountId::from_eth(caller);213 let from = T::CrossAccountId::from_eth(from);214 let amount = amount.try_into().map_err(|_| "amount overflow")?;215 let budget = self216 .recorder217 .weight_calls_budget(<StructureWeight<T>>::find_parent());218219 <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)220 .map_err(dispatch_to_evm::<T>)?;221 Ok(true)222 }223224 /// @dev Function that burns an amount of the token of a given account,225 /// deducting from the sender's allowance for said account.226 /// @param from The account whose tokens will be burnt.227 /// @param amount The amount that will be burnt.228 #[weight(<SelfWeightOf<T>>::burn_from())]229 fn burn_from_cross(230 &mut self,231 caller: caller,232 from: EthCrossAccount,233 amount: uint256,234 ) -> Result<bool> {235 let caller = T::CrossAccountId::from_eth(caller);236 let from = from.into_sub_cross_account::<T>()?;237 let amount = amount.try_into().map_err(|_| "amount overflow")?;238 let budget = self239 .recorder240 .weight_calls_budget(<StructureWeight<T>>::find_parent());241242 <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)243 .map_err(dispatch_to_evm::<T>)?;244 Ok(true)245 }246247 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.248 /// Beware that changing an allowance with this method brings the risk that someone may use both the old249 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this250 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:251 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729252 /// @param spender The crossaccount which will spend the funds.253 /// @param amount The amount of tokens to be spent.254 #[weight(<SelfWeightOf<T>>::approve())]255 fn approve_cross(256 &mut self,257 caller: caller,258 spender: EthCrossAccount,259 amount: uint256,260 ) -> Result<bool> {261 let caller = T::CrossAccountId::from_eth(caller);262 let spender = spender.into_sub_cross_account::<T>()?;263 let amount = amount.try_into().map_err(|_| "amount overflow")?;264265 <Pallet<T>>::set_allowance(self, &caller, &spender, self.1, amount)266 .map_err(dispatch_to_evm::<T>)?;267 Ok(true)268 }269 /// @dev Function that changes total amount of the tokens.270 /// Throws if `msg.sender` doesn't owns all of the tokens.271 /// @param amount New total amount of the tokens.272 #[weight(<SelfWeightOf<T>>::repartition_item())]273 fn repartition(&mut self, caller: caller, amount: uint256) -> Result<bool> {274 let caller = T::CrossAccountId::from_eth(caller);275 let amount = amount.try_into().map_err(|_| "amount overflow")?;276277 <Pallet<T>>::repartition(self, &caller, self.1, amount).map_err(dispatch_to_evm::<T>)?;278 Ok(true)279 }280281 /// @dev Transfer token for a specified address282 /// @param to The crossaccount to transfer to.283 /// @param amount The amount to be transferred.284 #[weight(<CommonWeights<T>>::transfer())]285 fn transfer_cross(286 &mut self,287 caller: caller,288 to: EthCrossAccount,289 amount: uint256,290 ) -> Result<bool> {291 let caller = T::CrossAccountId::from_eth(caller);292 let to = to.into_sub_cross_account::<T>()?;293 let amount = amount.try_into().map_err(|_| "amount overflow")?;294 let budget = self295 .recorder296 .weight_calls_budget(<StructureWeight<T>>::find_parent());297298 <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)299 .map_err(dispatch_to_evm::<T>)?;300 Ok(true)301 }302}303304impl<T: Config> RefungibleTokenHandle<T> {305 pub fn into_inner(self) -> RefungibleHandle<T> {306 self.0307 }308 pub fn common_mut(&mut self) -> &mut RefungibleHandle<T> {309 &mut self.0310 }311}312313impl<T: Config> WithRecorder<T> for RefungibleTokenHandle<T> {314 fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {315 self.0.recorder()316 }317 fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {318 self.0.into_recorder()319 }320}321322impl<T: Config> Deref for RefungibleTokenHandle<T> {323 type Target = RefungibleHandle<T>;324325 fn deref(&self) -> &Self::Target {326 &self.0327 }328}329330#[solidity_interface(331 name = UniqueRefungibleToken,332 is(ERC20, ERC20UniqueExtensions, ERC1633)333)]334impl<T: Config> RefungibleTokenHandle<T> where T::AccountId: From<[u8; 32]> {}335336generate_stubgen!(gen_impl, UniqueRefungibleTokenCall<()>, true);337generate_stubgen!(gen_iface, UniqueRefungibleTokenCall<()>, false);338339impl<T: Config> CommonEvmHandler for RefungibleTokenHandle<T>340where341 T::AccountId: From<[u8; 32]>,342{343 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungibleToken.raw");344345 fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {346 call::<T, UniqueRefungibleTokenCall<T>, _, _>(handle, self)347 }348}pallets/refungible/src/stubs/UniqueRefungibleToken.soldiffbeforeafterboth--- a/pallets/refungible/src/stubs/UniqueRefungibleToken.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungibleToken.sol
@@ -36,7 +36,7 @@
}
}
-/// @dev the ERC-165 identifier for this interface is 0xab8deb37
+/// @dev the ERC-165 identifier for this interface is 0x34b53e20
contract ERC20UniqueExtensions is Dummy, ERC165 {
/// @dev Function that burns an amount of the token of a given account,
/// deducting from the sender's allowance for said account.
@@ -52,6 +52,37 @@
return false;
}
+ /// @dev Function that burns an amount of the token of a given account,
+ /// deducting from the sender's allowance for said account.
+ /// @param from The account whose tokens will be burnt.
+ /// @param amount The amount that will be burnt.
+ /// @dev EVM selector for this function is: 0xbb2f5a58,
+ /// or in textual repr: burnFromCross((address,uint256),uint256)
+ function burnFromCross(EthCrossAccount memory from, uint256 amount) public returns (bool) {
+ require(false, stub_error);
+ from;
+ amount;
+ dummy = 0;
+ return false;
+ }
+
+ /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.
+ /// Beware that changing an allowance with this method brings the risk that someone may use both the old
+ /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ /// @param spender The crossaccount which will spend the funds.
+ /// @param amount The amount of tokens to be spent.
+ /// @dev EVM selector for this function is: 0x0ecd0ab0,
+ /// or in textual repr: approveCross((address,uint256),uint256)
+ function approveCross(EthCrossAccount memory spender, uint256 amount) public returns (bool) {
+ require(false, stub_error);
+ spender;
+ amount;
+ dummy = 0;
+ return false;
+ }
+
/// @dev Function that changes total amount of the tokens.
/// Throws if `msg.sender` doesn't owns all of the tokens.
/// @param amount New total amount of the tokens.
@@ -63,6 +94,25 @@
dummy = 0;
return false;
}
+
+ /// @dev Transfer token for a specified address
+ /// @param to The crossaccount to transfer to.
+ /// @param amount The amount to be transferred.
+ /// @dev EVM selector for this function is: 0x2ada85ff,
+ /// or in textual repr: transferCross((address,uint256),uint256)
+ function transferCross(EthCrossAccount memory to, uint256 amount) public returns (bool) {
+ require(false, stub_error);
+ to;
+ amount;
+ dummy = 0;
+ return false;
+ }
+}
+
+/// @dev Cross account struct
+struct EthCrossAccount {
+ address eth;
+ uint256 sub;
}
/// @dev inlined interface
tests/src/eth/abi/reFungibleToken.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungibleToken.json
+++ b/tests/src/eth/abi/reFungibleToken.json
@@ -71,6 +71,24 @@
},
{
"inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct EthCrossAccount",
+ "name": "spender",
+ "type": "tuple"
+ },
+ { "internalType": "uint256", "name": "amount", "type": "uint256" }
+ ],
+ "name": "approveCross",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
{ "internalType": "address", "name": "owner", "type": "address" }
],
"name": "balanceOf",
@@ -89,6 +107,24 @@
"type": "function"
},
{
+ "inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct EthCrossAccount",
+ "name": "from",
+ "type": "tuple"
+ },
+ { "internalType": "uint256", "name": "amount", "type": "uint256" }
+ ],
+ "name": "burnFromCross",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
"inputs": [],
"name": "decimals",
"outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }],
@@ -160,6 +196,24 @@
},
{
"inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct EthCrossAccount",
+ "name": "to",
+ "type": "tuple"
+ },
+ { "internalType": "uint256", "name": "amount", "type": "uint256" }
+ ],
+ "name": "transferCross",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
{ "internalType": "address", "name": "from", "type": "address" },
{ "internalType": "address", "name": "to", "type": "address" },
{ "internalType": "uint256", "name": "amount", "type": "uint256" }
tests/src/eth/api/UniqueRefungibleToken.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungibleToken.sol
+++ b/tests/src/eth/api/UniqueRefungibleToken.sol
@@ -23,7 +23,7 @@
function parentTokenId() external view returns (uint256);
}
-/// @dev the ERC-165 identifier for this interface is 0xab8deb37
+/// @dev the ERC-165 identifier for this interface is 0x34b53e20
interface ERC20UniqueExtensions is Dummy, ERC165 {
/// @dev Function that burns an amount of the token of a given account,
/// deducting from the sender's allowance for said account.
@@ -33,12 +33,44 @@
/// or in textual repr: burnFrom(address,uint256)
function burnFrom(address from, uint256 amount) external returns (bool);
+ /// @dev Function that burns an amount of the token of a given account,
+ /// deducting from the sender's allowance for said account.
+ /// @param from The account whose tokens will be burnt.
+ /// @param amount The amount that will be burnt.
+ /// @dev EVM selector for this function is: 0xbb2f5a58,
+ /// or in textual repr: burnFromCross((address,uint256),uint256)
+ function burnFromCross(EthCrossAccount memory from, uint256 amount) external returns (bool);
+
+ /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.
+ /// Beware that changing an allowance with this method brings the risk that someone may use both the old
+ /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ /// @param spender The crossaccount which will spend the funds.
+ /// @param amount The amount of tokens to be spent.
+ /// @dev EVM selector for this function is: 0x0ecd0ab0,
+ /// or in textual repr: approveCross((address,uint256),uint256)
+ function approveCross(EthCrossAccount memory spender, uint256 amount) external returns (bool);
+
/// @dev Function that changes total amount of the tokens.
/// Throws if `msg.sender` doesn't owns all of the tokens.
/// @param amount New total amount of the tokens.
/// @dev EVM selector for this function is: 0xd2418ca7,
/// or in textual repr: repartition(uint256)
function repartition(uint256 amount) external returns (bool);
+
+ /// @dev Transfer token for a specified address
+ /// @param to The crossaccount to transfer to.
+ /// @param amount The amount to be transferred.
+ /// @dev EVM selector for this function is: 0x2ada85ff,
+ /// or in textual repr: transferCross((address,uint256),uint256)
+ function transferCross(EthCrossAccount memory to, uint256 amount) external returns (bool);
+}
+
+/// @dev Cross account struct
+struct EthCrossAccount {
+ address eth;
+ uint256 sub;
}
/// @dev inlined interface
tests/src/eth/reFungibleToken.test.tsdiffbeforeafterboth--- a/tests/src/eth/reFungibleToken.test.ts
+++ b/tests/src/eth/reFungibleToken.test.ts
@@ -159,7 +159,33 @@
expect(+allowance).to.equal(100);
}
});
+
+ itEth('Can perform approveCross()', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const spender = helper.eth.createAccount();
+ const spenderCross = helper.ethCrossAccount.fromAddress(spender);
+
+ const collection = await helper.rft.mintCollection(alice);
+ const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
+
+ const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
+ const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
+
+ {
+ const result = await contract.methods.approveCross(spenderCross, 100).send({from: owner});
+ const event = result.events.Approval;
+ expect(event.address).to.be.equal(tokenAddress);
+ expect(event.returnValues.owner).to.be.equal(owner);
+ expect(event.returnValues.spender).to.be.equal(spender);
+ expect(event.returnValues.value).to.be.equal('100');
+ }
+ {
+ const allowance = await contract.methods.allowance(owner, spender).call();
+ expect(+allowance).to.equal(100);
+ }
+ });
+
itEth('Can perform transferFrom()', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const spender = await helper.eth.createAccountWithBalance(donor);
@@ -226,7 +252,7 @@
expect(+balance).to.equal(50);
}
});
-
+
[
'transfer',
// 'transferCross', // TODO
@@ -267,6 +293,35 @@
expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);
}));
+ itEth('Can perform transferCross()', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const receiver = helper.eth.createAccount();
+ const receiverCross = helper.ethCrossAccount.fromAddress(receiver);
+ const collection = await helper.rft.mintCollection(alice);
+ const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
+
+ const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
+ const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
+
+ {
+ const result = await contract.methods.transferCross(receiverCross, 50).send({from: owner});
+ const event = result.events.Transfer;
+ expect(event.address).to.be.equal(tokenAddress);
+ expect(event.returnValues.from).to.be.equal(owner);
+ expect(event.returnValues.to).to.be.equal(receiver);
+ expect(event.returnValues.value).to.be.equal('50');
+ }
+
+ {
+ const balance = await contract.methods.balanceOf(owner).call();
+ expect(+balance).to.equal(150);
+ }
+
+ {
+ const balance = await contract.methods.balanceOf(receiver).call();
+ expect(+balance).to.equal(50);
+ }
+ });
itEth('Can perform repartition()', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
const receiver = await helper.eth.createAccountWithBalance(donor);
@@ -353,6 +408,25 @@
expect(event.returnValues.to).to.be.equal(receiver);
expect(event.returnValues.tokenId).to.be.equal(tokenId);
});
+
+ itEth('Can perform burnFromCross()', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const spender = await helper.eth.createAccountWithBalance(donor);
+ const spenderCross = helper.ethCrossAccount.fromAddress(spender);
+
+ const collection = await helper.rft.mintCollection(alice);
+ const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
+
+ const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
+ const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
+
+ await contract.methods.approveCross(spenderCross, 100).send({from: owner});
+
+ await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;
+ await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;
+ expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');
+ });
});
describe('Refungible: Fees', () => {