git.delta.rocks / unique-network / refs/commits / b238f7bade8b

35use pallet_common::{35use pallet_common::{
36	CommonWeightInfo,36	CommonWeightInfo,
37	erc::{CommonEvmHandler, PrecompileResult},37	erc::{CommonEvmHandler, PrecompileResult},
38	eth::collection_id_to_address,38	eth::{collection_id_to_address, EthCrossAccount},
39};39};
40use pallet_evm::{account::CrossAccountId, PrecompileHandle};40use pallet_evm::{account::CrossAccountId, PrecompileHandle};
41use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};41use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};
200200
201#[solidity_interface(name = ERC20UniqueExtensions)]201#[solidity_interface(name = ERC20UniqueExtensions)]
202impl<T: Config> RefungibleTokenHandle<T> {202impl<T: Config> RefungibleTokenHandle<T>
203where
204	T::AccountId: From<[u8; 32]>,
205{
203	/// @dev Function that burns an amount of the token of a given account,206	/// @dev Function that burns an amount of the token of a given account,
204	/// deducting from the sender's allowance for said account.207	/// deducting from the sender's allowance for said account.
218		Ok(true)221		Ok(true)
219	}222	}
220223
224	/// @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 = self
239			.recorder
240			.weight_calls_budget(<StructureWeight<T>>::find_parent());
241
242		<Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)
243			.map_err(dispatch_to_evm::<T>)?;
244		Ok(true)
245	}
246
247	/// @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 old
249	/// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
250	/// 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-263524729
252	/// @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")?;
264
265		<Pallet<T>>::set_allowance(self, &caller, &spender, self.1, amount)
266			.map_err(dispatch_to_evm::<T>)?;
267		Ok(true)
268	}
221	/// @dev Function that changes total amount of the tokens.269	/// @dev Function that changes total amount of the tokens.
222	///  Throws if `msg.sender` doesn't owns all of the tokens.270	///  Throws if `msg.sender` doesn't owns all of the tokens.
223	/// @param amount New total amount of the tokens.271	/// @param amount New total amount of the tokens.
230		Ok(true)278		Ok(true)
231	}279	}
280
281	/// @dev Transfer token for a specified address
282	/// @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 = self
295			.recorder
296			.weight_calls_budget(<StructureWeight<T>>::find_parent());
297
298		<Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)
299			.map_err(dispatch_to_evm::<T>)?;
300		Ok(true)
301	}
232}302}
233303
234impl<T: Config> RefungibleTokenHandle<T> {304impl<T: Config> RefungibleTokenHandle<T> {

--- 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

--- 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" }

--- 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

--- 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', () => {