difftreelog
feat add allowanceCross method
in: master
22 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6360,7 +6360,7 @@
[[package]]
name = "pallet-fungible"
-version = "0.1.9"
+version = "0.1.10"
dependencies = [
"evm-coder",
"frame-benchmarking",
@@ -6773,7 +6773,7 @@
[[package]]
name = "pallet-refungible"
-version = "0.2.12"
+version = "0.2.13"
dependencies = [
"evm-coder",
"frame-benchmarking",
pallets/evm-contract-helpers/src/stubs/ContractHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/CHANGELOG.mddiffbeforeafterboth--- a/pallets/fungible/CHANGELOG.md
+++ b/pallets/fungible/CHANGELOG.md
@@ -4,6 +4,12 @@
<!-- bureaucrate goes here -->
+## [0.1.10] - 2023-02-01
+
+### Added
+
+- The functions `allowanceCross` to `ERC20UniqueExtensions` interface.
+
## [0.1.9] - 2022-12-01
### Added
pallets/fungible/Cargo.tomldiffbeforeafterboth--- a/pallets/fungible/Cargo.toml
+++ b/pallets/fungible/Cargo.toml
@@ -2,7 +2,7 @@
edition = "2021"
license = "GPLv3"
name = "pallet-fungible"
-version = "0.1.9"
+version = "0.1.10"
[dependencies]
# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -161,6 +161,21 @@
where
T::AccountId: From<[u8; 32]>,
{
+ /// @dev Function to check the amount of tokens that an owner allowed to a spender.
+ /// @param owner crossAddress The address which owns the funds.
+ /// @param spender crossAddress The address which will spend the funds.
+ /// @return A uint256 specifying the amount of tokens still available for the spender.
+ fn allowance_cross(
+ &self,
+ owner: pallet_common::eth::CrossAddress,
+ spender: pallet_common::eth::CrossAddress,
+ ) -> Result<U256> {
+ let owner = owner.into_sub_cross_account::<T>()?;
+ let spender = spender.into_sub_cross_account::<T>()?;
+
+ Ok(<Allowance<T>>::get((self.id, owner, spender)).into())
+ }
+
/// @notice A description for the collection.
fn description(&self) -> Result<String> {
Ok(decode_utf16(self.description.iter().copied())
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
@@ -511,8 +511,22 @@
bytes value;
}
-/// @dev the ERC-165 identifier for this interface is 0x65789571
+/// @dev the ERC-165 identifier for this interface is 0x85d7dea6
contract ERC20UniqueExtensions is Dummy, ERC165 {
+ /// @dev Function to check the amount of tokens that an owner allowed to a spender.
+ /// @param owner crossAddress The address which owns the funds.
+ /// @param spender crossAddress The address which will spend the funds.
+ /// @return A uint256 specifying the amount of tokens still available for the spender.
+ /// @dev EVM selector for this function is: 0xe0af4bd7,
+ /// or in textual repr: allowanceCross((address,uint256),(address,uint256))
+ function allowanceCross(CrossAddress memory owner, CrossAddress memory spender) public view returns (uint256) {
+ require(false, stub_error);
+ owner;
+ spender;
+ dummy;
+ return 0;
+ }
+
/// @notice A description for the collection.
/// @dev EVM selector for this function is: 0x7284e416,
/// or in textual repr: description()
@@ -576,7 +590,7 @@
/// @param amounts array of pairs of account address and amount
/// @dev EVM selector for this function is: 0x1acf2d55,
/// or in textual repr: mintBulk((address,uint256)[])
- function mintBulk(Tuple9[] memory amounts) public returns (bool) {
+ function mintBulk(Tuple11[] memory amounts) public returns (bool) {
require(false, stub_error);
amounts;
dummy = 0;
@@ -619,7 +633,7 @@
}
/// @dev anonymous struct
-struct Tuple9 {
+struct Tuple11 {
address field_0;
uint256 field_1;
}
pallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/CHANGELOG.mddiffbeforeafterboth--- a/pallets/refungible/CHANGELOG.md
+++ b/pallets/refungible/CHANGELOG.md
@@ -4,6 +4,12 @@
<!-- bureaucrate goes here -->
+## [0.2.13] - 2023-02-01
+
+### Added
+
+- The functions `allowanceCross` to `ERC20UniqueExtensions` interface.
+
## [0.2.12] - 2023-01-20
### Fixed
pallets/refungible/Cargo.tomldiffbeforeafterboth--- a/pallets/refungible/Cargo.toml
+++ b/pallets/refungible/Cargo.toml
@@ -2,7 +2,7 @@
edition = "2021"
license = "GPLv3"
name = "pallet-refungible"
-version = "0.2.12"
+version = "0.2.13"
[dependencies]
# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.
pallets/refungible/src/erc_token.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -203,6 +203,21 @@
where
T::AccountId: From<[u8; 32]>,
{
+ /// @dev Function to check the amount of tokens that an owner allowed to a spender.
+ /// @param owner crossAddress The address which owns the funds.
+ /// @param spender crossAddress The address which will spend the funds.
+ /// @return A uint256 specifying the amount of tokens still available for the spender.
+ fn allowance_cross(
+ &self,
+ owner: pallet_common::eth::CrossAddress,
+ spender: pallet_common::eth::CrossAddress,
+ ) -> Result<U256> {
+ let owner = owner.into_sub_cross_account::<T>()?;
+ let spender = spender.into_sub_cross_account::<T>()?;
+
+ Ok(<Allowance<T>>::get((self.id, self.1, owner, spender)).into())
+ }
+
/// @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.
pallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungibleToken.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungibleToken.soldiffbeforeafterboth1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @dev the ERC-165 identifier for this interface is 0x5755c3f221contract ERC1633 is Dummy, ERC165 {22 /// @dev EVM selector for this function is: 0x80a54001,23 /// or in textual repr: parentToken()24 function parentToken() public view returns (address) {25 require(false, stub_error);26 dummy;27 return 0x0000000000000000000000000000000000000000;28 }2930 /// @dev EVM selector for this function is: 0xd7f083f3,31 /// or in textual repr: parentTokenId()32 function parentTokenId() public view returns (uint256) {33 require(false, stub_error);34 dummy;35 return 0;36 }37}3839/// @dev the ERC-165 identifier for this interface is 0xe17a7d2b40contract ERC20UniqueExtensions is Dummy, ERC165 {41 // /// @dev Function that burns an amount of the token of a given account,42 // /// deducting from the sender's allowance for said account.43 // /// @param from The account whose tokens will be burnt.44 // /// @param amount The amount that will be burnt.45 // /// @dev EVM selector for this function is: 0x79cc6790,46 // /// or in textual repr: burnFrom(address,uint256)47 // function burnFrom(address from, uint256 amount) public returns (bool) {48 // require(false, stub_error);49 // from;50 // amount;51 // dummy = 0;52 // return false;53 // }5455 /// @dev Function that burns an amount of the token of a given account,56 /// deducting from the sender's allowance for said account.57 /// @param from The account whose tokens will be burnt.58 /// @param amount The amount that will be burnt.59 /// @dev EVM selector for this function is: 0xbb2f5a58,60 /// or in textual repr: burnFromCross((address,uint256),uint256)61 function burnFromCross(CrossAddress memory from, uint256 amount) public returns (bool) {62 require(false, stub_error);63 from;64 amount;65 dummy = 0;66 return false;67 }6869 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.70 /// Beware that changing an allowance with this method brings the risk that someone may use both the old71 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this72 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:73 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-26352472974 /// @param spender The crossaccount which will spend the funds.75 /// @param amount The amount of tokens to be spent.76 /// @dev EVM selector for this function is: 0x0ecd0ab0,77 /// or in textual repr: approveCross((address,uint256),uint256)78 function approveCross(CrossAddress memory spender, uint256 amount) public returns (bool) {79 require(false, stub_error);80 spender;81 amount;82 dummy = 0;83 return false;84 }8586 /// @dev Function that changes total amount of the tokens.87 /// Throws if `msg.sender` doesn't owns all of the tokens.88 /// @param amount New total amount of the tokens.89 /// @dev EVM selector for this function is: 0xd2418ca7,90 /// or in textual repr: repartition(uint256)91 function repartition(uint256 amount) public returns (bool) {92 require(false, stub_error);93 amount;94 dummy = 0;95 return false;96 }9798 /// @dev Transfer token for a specified address99 /// @param to The crossaccount to transfer to.100 /// @param amount The amount to be transferred.101 /// @dev EVM selector for this function is: 0x2ada85ff,102 /// or in textual repr: transferCross((address,uint256),uint256)103 function transferCross(CrossAddress memory to, uint256 amount) public returns (bool) {104 require(false, stub_error);105 to;106 amount;107 dummy = 0;108 return false;109 }110111 /// @dev Transfer tokens from one address to another112 /// @param from The address which you want to send tokens from113 /// @param to The address which you want to transfer to114 /// @param amount the amount of tokens to be transferred115 /// @dev EVM selector for this function is: 0xd5cf430b,116 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)117 function transferFromCross(118 CrossAddress memory from,119 CrossAddress memory to,120 uint256 amount121 ) public returns (bool) {122 require(false, stub_error);123 from;124 to;125 amount;126 dummy = 0;127 return false;128 }129}130131/// Cross account struct132struct CrossAddress {133 address eth;134 uint256 sub;135}136137/// @dev inlined interface138contract ERC20Events {139 event Transfer(address indexed from, address indexed to, uint256 value);140 event Approval(address indexed owner, address indexed spender, uint256 value);141}142143/// @title Standard ERC20 token144///145/// @dev Implementation of the basic standard token.146/// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md147/// @dev the ERC-165 identifier for this interface is 0x942e8b22148contract ERC20 is Dummy, ERC165, ERC20Events {149 /// @return the name of the token.150 /// @dev EVM selector for this function is: 0x06fdde03,151 /// or in textual repr: name()152 function name() public view returns (string memory) {153 require(false, stub_error);154 dummy;155 return "";156 }157158 /// @return the symbol of the token.159 /// @dev EVM selector for this function is: 0x95d89b41,160 /// or in textual repr: symbol()161 function symbol() public view returns (string memory) {162 require(false, stub_error);163 dummy;164 return "";165 }166167 /// @dev Total number of tokens in existence168 /// @dev EVM selector for this function is: 0x18160ddd,169 /// or in textual repr: totalSupply()170 function totalSupply() public view returns (uint256) {171 require(false, stub_error);172 dummy;173 return 0;174 }175176 /// @dev Not supported177 /// @dev EVM selector for this function is: 0x313ce567,178 /// or in textual repr: decimals()179 function decimals() public view returns (uint8) {180 require(false, stub_error);181 dummy;182 return 0;183 }184185 /// @dev Gets the balance of the specified address.186 /// @param owner The address to query the balance of.187 /// @return An uint256 representing the amount owned by the passed address.188 /// @dev EVM selector for this function is: 0x70a08231,189 /// or in textual repr: balanceOf(address)190 function balanceOf(address owner) public view returns (uint256) {191 require(false, stub_error);192 owner;193 dummy;194 return 0;195 }196197 /// @dev Transfer token for a specified address198 /// @param to The address to transfer to.199 /// @param amount The amount to be transferred.200 /// @dev EVM selector for this function is: 0xa9059cbb,201 /// or in textual repr: transfer(address,uint256)202 function transfer(address to, uint256 amount) public returns (bool) {203 require(false, stub_error);204 to;205 amount;206 dummy = 0;207 return false;208 }209210 /// @dev Transfer tokens from one address to another211 /// @param from address The address which you want to send tokens from212 /// @param to address The address which you want to transfer to213 /// @param amount uint256 the amount of tokens to be transferred214 /// @dev EVM selector for this function is: 0x23b872dd,215 /// or in textual repr: transferFrom(address,address,uint256)216 function transferFrom(217 address from,218 address to,219 uint256 amount220 ) public returns (bool) {221 require(false, stub_error);222 from;223 to;224 amount;225 dummy = 0;226 return false;227 }228229 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.230 /// Beware that changing an allowance with this method brings the risk that someone may use both the old231 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this232 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:233 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729234 /// @param spender The address which will spend the funds.235 /// @param amount The amount of tokens to be spent.236 /// @dev EVM selector for this function is: 0x095ea7b3,237 /// or in textual repr: approve(address,uint256)238 function approve(address spender, uint256 amount) public returns (bool) {239 require(false, stub_error);240 spender;241 amount;242 dummy = 0;243 return false;244 }245246 /// @dev Function to check the amount of tokens that an owner allowed to a spender.247 /// @param owner address The address which owns the funds.248 /// @param spender address The address which will spend the funds.249 /// @return A uint256 specifying the amount of tokens still available for the spender.250 /// @dev EVM selector for this function is: 0xdd62ed3e,251 /// or in textual repr: allowance(address,address)252 function allowance(address owner, address spender) public view returns (uint256) {253 require(false, stub_error);254 owner;255 spender;256 dummy;257 return 0;258 }259}260261contract UniqueRefungibleToken is Dummy, ERC165, ERC20, ERC20UniqueExtensions, ERC1633 {}1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @dev the ERC-165 identifier for this interface is 0x5755c3f221contract ERC1633 is Dummy, ERC165 {22 /// @dev EVM selector for this function is: 0x80a54001,23 /// or in textual repr: parentToken()24 function parentToken() public view returns (address) {25 require(false, stub_error);26 dummy;27 return 0x0000000000000000000000000000000000000000;28 }2930 /// @dev EVM selector for this function is: 0xd7f083f3,31 /// or in textual repr: parentTokenId()32 function parentTokenId() public view returns (uint256) {33 require(false, stub_error);34 dummy;35 return 0;36 }37}3839/// @dev the ERC-165 identifier for this interface is 0x01d536fc40contract ERC20UniqueExtensions is Dummy, ERC165 {41 /// @dev Function to check the amount of tokens that an owner allowed to a spender.42 /// @param owner crossAddress The address which owns the funds.43 /// @param spender crossAddress The address which will spend the funds.44 /// @return A uint256 specifying the amount of tokens still available for the spender.45 /// @dev EVM selector for this function is: 0xe0af4bd7,46 /// or in textual repr: allowanceCross((address,uint256),(address,uint256))47 function allowanceCross(CrossAddress memory owner, CrossAddress memory spender) public view returns (uint256) {48 require(false, stub_error);49 owner;50 spender;51 dummy;52 return 0;53 }5455 // /// @dev Function that burns an amount of the token of a given account,56 // /// deducting from the sender's allowance for said account.57 // /// @param from The account whose tokens will be burnt.58 // /// @param amount The amount that will be burnt.59 // /// @dev EVM selector for this function is: 0x79cc6790,60 // /// or in textual repr: burnFrom(address,uint256)61 // function burnFrom(address from, uint256 amount) public returns (bool) {62 // require(false, stub_error);63 // from;64 // amount;65 // dummy = 0;66 // return false;67 // }6869 /// @dev Function that burns an amount of the token of a given account,70 /// deducting from the sender's allowance for said account.71 /// @param from The account whose tokens will be burnt.72 /// @param amount The amount that will be burnt.73 /// @dev EVM selector for this function is: 0xbb2f5a58,74 /// or in textual repr: burnFromCross((address,uint256),uint256)75 function burnFromCross(CrossAddress memory from, uint256 amount) public returns (bool) {76 require(false, stub_error);77 from;78 amount;79 dummy = 0;80 return false;81 }8283 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.84 /// Beware that changing an allowance with this method brings the risk that someone may use both the old85 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this86 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:87 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-26352472988 /// @param spender The crossaccount which will spend the funds.89 /// @param amount The amount of tokens to be spent.90 /// @dev EVM selector for this function is: 0x0ecd0ab0,91 /// or in textual repr: approveCross((address,uint256),uint256)92 function approveCross(CrossAddress memory spender, uint256 amount) public returns (bool) {93 require(false, stub_error);94 spender;95 amount;96 dummy = 0;97 return false;98 }99100 /// @dev Function that changes total amount of the tokens.101 /// Throws if `msg.sender` doesn't owns all of the tokens.102 /// @param amount New total amount of the tokens.103 /// @dev EVM selector for this function is: 0xd2418ca7,104 /// or in textual repr: repartition(uint256)105 function repartition(uint256 amount) public returns (bool) {106 require(false, stub_error);107 amount;108 dummy = 0;109 return false;110 }111112 /// @dev Transfer token for a specified address113 /// @param to The crossaccount to transfer to.114 /// @param amount The amount to be transferred.115 /// @dev EVM selector for this function is: 0x2ada85ff,116 /// or in textual repr: transferCross((address,uint256),uint256)117 function transferCross(CrossAddress memory to, uint256 amount) public returns (bool) {118 require(false, stub_error);119 to;120 amount;121 dummy = 0;122 return false;123 }124125 /// @dev Transfer tokens from one address to another126 /// @param from The address which you want to send tokens from127 /// @param to The address which you want to transfer to128 /// @param amount the amount of tokens to be transferred129 /// @dev EVM selector for this function is: 0xd5cf430b,130 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)131 function transferFromCross(132 CrossAddress memory from,133 CrossAddress memory to,134 uint256 amount135 ) public returns (bool) {136 require(false, stub_error);137 from;138 to;139 amount;140 dummy = 0;141 return false;142 }143}144145/// Cross account struct146struct CrossAddress {147 address eth;148 uint256 sub;149}150151/// @dev inlined interface152contract ERC20Events {153 event Transfer(address indexed from, address indexed to, uint256 value);154 event Approval(address indexed owner, address indexed spender, uint256 value);155}156157/// @title Standard ERC20 token158///159/// @dev Implementation of the basic standard token.160/// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md161/// @dev the ERC-165 identifier for this interface is 0x942e8b22162contract ERC20 is Dummy, ERC165, ERC20Events {163 /// @return the name of the token.164 /// @dev EVM selector for this function is: 0x06fdde03,165 /// or in textual repr: name()166 function name() public view returns (string memory) {167 require(false, stub_error);168 dummy;169 return "";170 }171172 /// @return the symbol of the token.173 /// @dev EVM selector for this function is: 0x95d89b41,174 /// or in textual repr: symbol()175 function symbol() public view returns (string memory) {176 require(false, stub_error);177 dummy;178 return "";179 }180181 /// @dev Total number of tokens in existence182 /// @dev EVM selector for this function is: 0x18160ddd,183 /// or in textual repr: totalSupply()184 function totalSupply() public view returns (uint256) {185 require(false, stub_error);186 dummy;187 return 0;188 }189190 /// @dev Not supported191 /// @dev EVM selector for this function is: 0x313ce567,192 /// or in textual repr: decimals()193 function decimals() public view returns (uint8) {194 require(false, stub_error);195 dummy;196 return 0;197 }198199 /// @dev Gets the balance of the specified address.200 /// @param owner The address to query the balance of.201 /// @return An uint256 representing the amount owned by the passed address.202 /// @dev EVM selector for this function is: 0x70a08231,203 /// or in textual repr: balanceOf(address)204 function balanceOf(address owner) public view returns (uint256) {205 require(false, stub_error);206 owner;207 dummy;208 return 0;209 }210211 /// @dev Transfer token for a specified address212 /// @param to The address to transfer to.213 /// @param amount The amount to be transferred.214 /// @dev EVM selector for this function is: 0xa9059cbb,215 /// or in textual repr: transfer(address,uint256)216 function transfer(address to, uint256 amount) public returns (bool) {217 require(false, stub_error);218 to;219 amount;220 dummy = 0;221 return false;222 }223224 /// @dev Transfer tokens from one address to another225 /// @param from address The address which you want to send tokens from226 /// @param to address The address which you want to transfer to227 /// @param amount uint256 the amount of tokens to be transferred228 /// @dev EVM selector for this function is: 0x23b872dd,229 /// or in textual repr: transferFrom(address,address,uint256)230 function transferFrom(231 address from,232 address to,233 uint256 amount234 ) public returns (bool) {235 require(false, stub_error);236 from;237 to;238 amount;239 dummy = 0;240 return false;241 }242243 /// @dev Approve the passed address to spend the specified amount of tokens on behalf of `msg.sender`.244 /// Beware that changing an allowance with this method brings the risk that someone may use both the old245 /// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this246 /// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:247 /// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729248 /// @param spender The address which will spend the funds.249 /// @param amount The amount of tokens to be spent.250 /// @dev EVM selector for this function is: 0x095ea7b3,251 /// or in textual repr: approve(address,uint256)252 function approve(address spender, uint256 amount) public returns (bool) {253 require(false, stub_error);254 spender;255 amount;256 dummy = 0;257 return false;258 }259260 /// @dev Function to check the amount of tokens that an owner allowed to a spender.261 /// @param owner address The address which owns the funds.262 /// @param spender address The address which will spend the funds.263 /// @return A uint256 specifying the amount of tokens still available for the spender.264 /// @dev EVM selector for this function is: 0xdd62ed3e,265 /// or in textual repr: allowance(address,address)266 function allowance(address owner, address spender) public view returns (uint256) {267 require(false, stub_error);268 owner;269 spender;270 dummy;271 return 0;272 }273}274275contract UniqueRefungibleToken is Dummy, ERC165, ERC20, ERC20UniqueExtensions, ERC1633 {}pallets/unique/src/eth/stubs/CollectionHelpers.rawdiffbeforeafterbothbinary blob — no preview
runtime/common/ethereum/sponsoring/refungible.rsdiffbeforeafterboth--- a/runtime/common/ethereum/sponsoring/refungible.rs
+++ b/runtime/common/ethereum/sponsoring/refungible.rs
@@ -341,7 +341,9 @@
ERC165Call(_, _) => None,
// Not sponsored
- BurnFrom { .. } | BurnFromCross { .. } | Repartition { .. } => None,
+ AllowanceCross { .. } | BurnFrom { .. } | BurnFromCross { .. } | Repartition { .. } => {
+ None
+ }
TransferCross { .. } | TransferFromCross { .. } => {
let RefungibleTokenHandle(handle, token_id) = token;
tests/src/eth/abi/fungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/fungible.json
+++ b/tests/src/eth/abi/fungible.json
@@ -101,6 +101,32 @@
{ "internalType": "uint256", "name": "sub", "type": "uint256" }
],
"internalType": "struct CrossAddress",
+ "name": "owner",
+ "type": "tuple"
+ },
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct CrossAddress",
+ "name": "spender",
+ "type": "tuple"
+ }
+ ],
+ "name": "allowanceCross",
+ "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct CrossAddress",
"name": "user",
"type": "tuple"
}
@@ -411,7 +437,7 @@
{ "internalType": "address", "name": "field_0", "type": "address" },
{ "internalType": "uint256", "name": "field_1", "type": "uint256" }
],
- "internalType": "struct Tuple9[]",
+ "internalType": "struct Tuple11[]",
"name": "amounts",
"type": "tuple[]"
}
tests/src/eth/abi/reFungibleToken.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungibleToken.json
+++ b/tests/src/eth/abi/reFungibleToken.json
@@ -61,6 +61,32 @@
},
{
"inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct CrossAddress",
+ "name": "owner",
+ "type": "tuple"
+ },
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct CrossAddress",
+ "name": "spender",
+ "type": "tuple"
+ }
+ ],
+ "name": "allowanceCross",
+ "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "inputs": [
{ "internalType": "address", "name": "spender", "type": "address" },
{ "internalType": "uint256", "name": "amount", "type": "uint256" }
],
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -353,8 +353,16 @@
bytes value;
}
-/// @dev the ERC-165 identifier for this interface is 0x65789571
+/// @dev the ERC-165 identifier for this interface is 0x85d7dea6
interface ERC20UniqueExtensions is Dummy, ERC165 {
+ /// @dev Function to check the amount of tokens that an owner allowed to a spender.
+ /// @param owner crossAddress The address which owns the funds.
+ /// @param spender crossAddress The address which will spend the funds.
+ /// @return A uint256 specifying the amount of tokens still available for the spender.
+ /// @dev EVM selector for this function is: 0xe0af4bd7,
+ /// or in textual repr: allowanceCross((address,uint256),(address,uint256))
+ function allowanceCross(CrossAddress memory owner, CrossAddress memory spender) external view returns (uint256);
+
/// @notice A description for the collection.
/// @dev EVM selector for this function is: 0x7284e416,
/// or in textual repr: description()
@@ -390,7 +398,7 @@
/// @param amounts array of pairs of account address and amount
/// @dev EVM selector for this function is: 0x1acf2d55,
/// or in textual repr: mintBulk((address,uint256)[])
- function mintBulk(Tuple9[] memory amounts) external returns (bool);
+ function mintBulk(Tuple11[] memory amounts) external returns (bool);
/// @dev EVM selector for this function is: 0x2ada85ff,
/// or in textual repr: transferCross((address,uint256),uint256)
@@ -411,7 +419,7 @@
}
/// @dev anonymous struct
-struct Tuple9 {
+struct Tuple11 {
address field_0;
uint256 field_1;
}
tests/src/eth/api/UniqueRefungibleToken.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungibleToken.sol
+++ b/tests/src/eth/api/UniqueRefungibleToken.sol
@@ -23,8 +23,16 @@
function parentTokenId() external view returns (uint256);
}
-/// @dev the ERC-165 identifier for this interface is 0xe17a7d2b
+/// @dev the ERC-165 identifier for this interface is 0x01d536fc
interface ERC20UniqueExtensions is Dummy, ERC165 {
+ /// @dev Function to check the amount of tokens that an owner allowed to a spender.
+ /// @param owner crossAddress The address which owns the funds.
+ /// @param spender crossAddress The address which will spend the funds.
+ /// @return A uint256 specifying the amount of tokens still available for the spender.
+ /// @dev EVM selector for this function is: 0xe0af4bd7,
+ /// or in textual repr: allowanceCross((address,uint256),(address,uint256))
+ function allowanceCross(CrossAddress memory owner, CrossAddress memory spender) external view returns (uint256);
+
// /// @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.
tests/src/eth/fungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -134,6 +134,12 @@
const allowance = await contract.methods.allowance(owner, spender).call();
expect(+allowance).to.equal(100);
}
+ {
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const spenderCross = helper.ethCrossAccount.fromAddress(spender);
+ const allowance = await contract.methods.allowanceCross(ownerCross, spenderCross).call();
+ expect(+allowance).to.equal(100);
+ }
});
itEth('Can perform approveCross()', async ({helper}) => {
tests/src/eth/reFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -219,8 +219,16 @@
await rftToken.methods.approve(operator, 15n).send({from: owner});
await contract.methods.setApprovalForAll(operator, true).send({from: owner});
await rftToken.methods.burnFrom(owner, 10n).send({from: operator});
+ }
+ {
const allowance = await rftToken.methods.allowance(owner, operator).call();
- expect(allowance).to.be.equal('5');
+ expect(+allowance).to.be.equal(5);
+ }
+ {
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const operatorCross = helper.ethCrossAccount.fromAddress(operator);
+ const allowance = await rftToken.methods.allowanceCross(ownerCross, operatorCross).call();
+ expect(+allowance).to.equal(5);
}
});