difftreelog
Merge pull request #750 from UniqueNetwork/feature/cross-methods-refungible-erc20-support
in: master
added cross methods: `burnFromCross` , `transferCross`, `approveCorss…
9 files changed
pallets/refungible/src/erc_token.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -30,7 +30,7 @@
use pallet_common::{
CommonWeightInfo,
erc::{CommonEvmHandler, PrecompileResult},
- eth::collection_id_to_address,
+ eth::{collection_id_to_address, EthCrossAccount},
};
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder};
@@ -194,7 +194,10 @@
}
#[solidity_interface(name = ERC20UniqueExtensions)]
-impl<T: Config> RefungibleTokenHandle<T> {
+impl<T: Config> RefungibleTokenHandle<T>
+where
+ T::AccountId: From<[u8; 32]>,
+{
/// @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.
@@ -213,6 +216,51 @@
Ok(true)
}
+ /// @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.
+ #[weight(<SelfWeightOf<T>>::burn_from())]
+ fn burn_from_cross(
+ &mut self,
+ caller: caller,
+ from: EthCrossAccount,
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let from = from.into_sub_cross_account::<T>()?;
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+ let budget = self
+ .recorder
+ .weight_calls_budget(<StructureWeight<T>>::find_parent());
+
+ <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
+
+ /// @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.
+ #[weight(<SelfWeightOf<T>>::approve())]
+ fn approve_cross(
+ &mut self,
+ caller: caller,
+ spender: EthCrossAccount,
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let spender = spender.into_sub_cross_account::<T>()?;
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+ <Pallet<T>>::set_allowance(self, &caller, &spender, self.1, amount)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
/// @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.
@@ -224,6 +272,53 @@
<Pallet<T>>::repartition(self, &caller, self.1, amount).map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
+
+ /// @dev Transfer token for a specified address
+ /// @param to The crossaccount to transfer to.
+ /// @param amount The amount to be transferred.
+ #[weight(<CommonWeights<T>>::transfer())]
+ fn transfer_cross(
+ &mut self,
+ caller: caller,
+ to: EthCrossAccount,
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = to.into_sub_cross_account::<T>()?;
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+ let budget = self
+ .recorder
+ .weight_calls_budget(<StructureWeight<T>>::find_parent());
+
+ <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
+
+ /// @dev Transfer tokens from one address to another
+ /// @param from The address which you want to send tokens from
+ /// @param to The address which you want to transfer to
+ /// @param amount the amount of tokens to be transferred
+ #[weight(<CommonWeights<T>>::transfer_from())]
+ fn transfer_from_cross(
+ &mut self,
+ caller: caller,
+ from: EthCrossAccount,
+ to: EthCrossAccount,
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let from = from.into_sub_cross_account::<T>()?;
+ let to = to.into_sub_cross_account::<T>()?;
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+ let budget = self
+ .recorder
+ .weight_calls_budget(<StructureWeight<T>>::find_parent());
+
+ <Pallet<T>>::transfer_from(self, &caller, &from, &to, self.1, amount, &budget)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
}
impl<T: Config> RefungibleTokenHandle<T> {
pallets/refungible/src/stubs/UniqueRefungibleToken.rawdiffbeforeafterbothbinary blob — no preview
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 0xe17a7d2b
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,44 @@
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 Transfer tokens from one address to another
+ /// @param from The address which you want to send tokens from
+ /// @param to The address which you want to transfer to
+ /// @param amount the amount of tokens to be transferred
+ /// @dev EVM selector for this function is: 0xd5cf430b,
+ /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
+ function transferFromCross(
+ EthCrossAccount memory from,
+ EthCrossAccount memory to,
+ uint256 amount
+ ) public returns (bool) {
+ require(false, stub_error);
+ from;
+ 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" }
@@ -168,5 +222,32 @@
"outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
"stateMutability": "nonpayable",
"type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "eth", "type": "address" },
+ { "internalType": "uint256", "name": "sub", "type": "uint256" }
+ ],
+ "internalType": "struct EthCrossAccount",
+ "name": "from",
+ "type": "tuple"
+ },
+ {
+ "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": "transferFromCross",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
}
]
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 0xe17a7d2b
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,56 @@
/// 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 Transfer tokens from one address to another
+ /// @param from The address which you want to send tokens from
+ /// @param to The address which you want to transfer to
+ /// @param amount the amount of tokens to be transferred
+ /// @dev EVM selector for this function is: 0xd5cf430b,
+ /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
+ function transferFromCross(
+ EthCrossAccount memory from,
+ 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.tsdiffbeforeafterboth1// 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/>.1617import {Pallets, requirePalletsOrSkip} from '../util';18import {EthUniqueHelper, expect, itEth, usingEthPlaygrounds} from './util';19import {IKeyringPair} from '@polkadot/types/types';20import {Contract} from 'web3-eth-contract';212223describe('Refungible token: Information getting', () => {24 let donor: IKeyringPair;25 let alice: IKeyringPair;2627 before(async function() {28 await usingEthPlaygrounds(async (helper, privateKey) => {29 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);3031 donor = await privateKey({filename: __filename});32 [alice] = await helper.arrange.createAccounts([20n], donor);33 });34 });3536 itEth('totalSupply', async ({helper}) => {37 const caller = await helper.eth.createAccountWithBalance(donor);38 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});39 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});4041 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);42 const totalSupply = await contract.methods.totalSupply().call();43 expect(totalSupply).to.equal('200');44 });4546 itEth('balanceOf', async ({helper}) => {47 const caller = await helper.eth.createAccountWithBalance(donor);48 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});49 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});5051 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);52 const balance = await contract.methods.balanceOf(caller).call();53 expect(balance).to.equal('200');54 });5556 itEth('decimals', async ({helper}) => {57 const caller = await helper.eth.createAccountWithBalance(donor);58 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});59 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});6061 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);62 const decimals = await contract.methods.decimals().call();63 expect(decimals).to.equal('0');64 });65});6667// FIXME: Need erc721 for ReFubgible.68describe('Check ERC721 token URI for ReFungible', () => {69 let donor: IKeyringPair;7071 before(async function() {72 await usingEthPlaygrounds(async (helper, privateKey) => {73 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);7475 donor = await privateKey({filename: __filename});76 });77 });7879 async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {80 const owner = await helper.eth.createAccountWithBalance(donor);81 const receiver = helper.eth.createAccount();8283 const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);84 const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);8586 const result = await contract.methods.mint(receiver).send();8788 const event = result.events.Transfer;89 const tokenId = event.returnValues.tokenId;90 expect(tokenId).to.be.equal('1');91 expect(event.address).to.be.equal(collectionAddress);92 expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');93 expect(event.returnValues.to).to.be.equal(receiver);9495 if (propertyKey && propertyValue) {96 // Set URL or suffix9798 await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();99 }100101 return {contract, nextTokenId: tokenId};102 }103104 itEth('Empty tokenURI', async ({helper}) => {105 const {contract, nextTokenId} = await setup(helper, '');106 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');107 });108109 itEth('TokenURI from url', async ({helper}) => {110 const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');111 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');112 });113114 itEth('TokenURI from baseURI', async ({helper}) => {115 const {contract, nextTokenId} = await setup(helper, 'BaseURI_');116 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');117 });118119 itEth('TokenURI from baseURI + suffix', async ({helper}) => {120 const suffix = '/some/suffix';121 const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);122 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);123 });124});125126describe('Refungible: Plain calls', () => {127 let donor: IKeyringPair;128 let alice: IKeyringPair;129130 before(async function() {131 await usingEthPlaygrounds(async (helper, privateKey) => {132 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);133134 donor = await privateKey({filename: __filename});135 [alice] = await helper.arrange.createAccounts([50n], donor);136 });137 });138139 itEth('Can perform approve()', async ({helper}) => {140 const owner = await helper.eth.createAccountWithBalance(donor);141 const spender = helper.eth.createAccount();142 const collection = await helper.rft.mintCollection(alice);143 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});144145 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);146 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);147148 {149 const result = await contract.methods.approve(spender, 100).send({from: owner});150 const event = result.events.Approval;151 expect(event.address).to.be.equal(tokenAddress);152 expect(event.returnValues.owner).to.be.equal(owner);153 expect(event.returnValues.spender).to.be.equal(spender);154 expect(event.returnValues.value).to.be.equal('100');155 }156157 {158 const allowance = await contract.methods.allowance(owner, spender).call();159 expect(+allowance).to.equal(100);160 }161 });162163 itEth('Can perform transferFrom()', async ({helper}) => {164 const owner = await helper.eth.createAccountWithBalance(donor);165 const spender = await helper.eth.createAccountWithBalance(donor);166 const receiver = helper.eth.createAccount();167 const collection = await helper.rft.mintCollection(alice);168 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});169170 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);171 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);172173 await contract.methods.approve(spender, 100).send();174175 {176 const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});177 let event = result.events.Transfer;178 expect(event.address).to.be.equal(tokenAddress);179 expect(event.returnValues.from).to.be.equal(owner);180 expect(event.returnValues.to).to.be.equal(receiver);181 expect(event.returnValues.value).to.be.equal('49');182183 event = result.events.Approval;184 expect(event.address).to.be.equal(tokenAddress);185 expect(event.returnValues.owner).to.be.equal(owner);186 expect(event.returnValues.spender).to.be.equal(spender);187 expect(event.returnValues.value).to.be.equal('51');188 }189190 {191 const balance = await contract.methods.balanceOf(receiver).call();192 expect(+balance).to.equal(49);193 }194195 {196 const balance = await contract.methods.balanceOf(owner).call();197 expect(+balance).to.equal(151);198 }199 });200201 itEth('Can perform transfer()', async ({helper}) => {202 const owner = await helper.eth.createAccountWithBalance(donor);203 const receiver = helper.eth.createAccount();204 const collection = await helper.rft.mintCollection(alice);205 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});206207 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);208 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);209210 {211 const result = await contract.methods.transfer(receiver, 50).send({from: owner});212 const event = result.events.Transfer;213 expect(event.address).to.be.equal(tokenAddress);214 expect(event.returnValues.from).to.be.equal(owner);215 expect(event.returnValues.to).to.be.equal(receiver);216 expect(event.returnValues.value).to.be.equal('50');217 }218219 {220 const balance = await contract.methods.balanceOf(owner).call();221 expect(+balance).to.equal(150);222 }223224 {225 const balance = await contract.methods.balanceOf(receiver).call();226 expect(+balance).to.equal(50);227 }228 });229230 [231 'transfer',232 // 'transferCross', // TODO233 ].map(testCase => 234 itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {235 const owner = await helper.eth.createAccountWithBalance(donor);236 const receiver = await helper.eth.createAccountWithBalance(donor);237 const collection = await helper.rft.mintCollection(alice);238 const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});239 const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiver});240 const tokenIdNonExist = 9999999;241 242 const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);243 const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);244 const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);245 const tokenEvmOwner = helper.ethNativeContract.rftToken(tokenAddress1, owner);246 const tokenEvmReceiver = helper.ethNativeContract.rftToken(tokenAddress2, owner);247 const tokenEvmNonExist = helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);248 249 // 1. Can transfer zero amount (EIP-20):250 await tokenEvmOwner.methods[testCase](receiver, 0).send({from: owner});251 // 2. Cannot transfer non-owned token:252 await expect(tokenEvmReceiver.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;253 await expect(tokenEvmReceiver.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;254 // 3. Cannot transfer non-existing token:255 await expect(tokenEvmNonExist.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;256 await expect(tokenEvmNonExist.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;257258 // 4. Storage is not corrupted:259 expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);260 expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);261 expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]); // TODO262263 // 4.1 Tokens can be transferred:264 await tokenEvmOwner.methods[testCase](receiver, 10).send({from: owner});265 await tokenEvmReceiver.methods[testCase](owner, 10).send({from: receiver});266 expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);267 expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);268 }));269270 itEth('Can perform repartition()', async ({helper}) => {271 const owner = await helper.eth.createAccountWithBalance(donor);272 const receiver = await helper.eth.createAccountWithBalance(donor);273 const collection = await helper.rft.mintCollection(alice);274 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});275276 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);277 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);278279 await contract.methods.repartition(200).send({from: owner});280 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);281 await contract.methods.transfer(receiver, 110).send({from: owner});282 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);283 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);284285 await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted286287 await contract.methods.transfer(receiver, 90).send({from: owner});288 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);289 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);290291 await contract.methods.repartition(150).send({from: receiver});292 await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted293 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);294 });295296 itEth('Can repartition with increased amount', async ({helper}) => {297 const owner = await helper.eth.createAccountWithBalance(donor);298 const collection = await helper.rft.mintCollection(alice);299 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});300301 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);302 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);303304 const result = await contract.methods.repartition(200).send();305306 const event = result.events.Transfer;307 expect(event.address).to.be.equal(tokenAddress);308 expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');309 expect(event.returnValues.to).to.be.equal(owner);310 expect(event.returnValues.value).to.be.equal('100');311 });312313 itEth('Can repartition with decreased amount', async ({helper}) => {314 const owner = await helper.eth.createAccountWithBalance(donor);315 const collection = await helper.rft.mintCollection(alice);316 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});317318 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);319 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);320321 const result = await contract.methods.repartition(50).send();322 const event = result.events.Transfer;323 expect(event.address).to.be.equal(tokenAddress);324 expect(event.returnValues.from).to.be.equal(owner);325 expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');326 expect(event.returnValues.value).to.be.equal('50');327 });328329 itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {330 const caller = await helper.eth.createAccountWithBalance(donor);331 const receiver = await helper.eth.createAccountWithBalance(donor);332 const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');333 const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);334335 const result = await contract.methods.mint(caller).send();336 const tokenId = result.events.Transfer.returnValues.tokenId;337 const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);338 const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);339340 await tokenContract.methods.repartition(2).send();341 await tokenContract.methods.transfer(receiver, 1).send();342343 const events: any = [];344 contract.events.allEvents((_: any, event: any) => {345 events.push(event);346 });347 await tokenContract.methods.burnFrom(caller, 1).send();348349 if (events.length == 0) await helper.wait.newBlocks(1);350 const event = events[0];351 expect(event.address).to.be.equal(collectionAddress);352 expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');353 expect(event.returnValues.to).to.be.equal(receiver);354 expect(event.returnValues.tokenId).to.be.equal(tokenId);355 });356});357358describe('Refungible: Fees', () => {359 let donor: IKeyringPair;360 let alice: IKeyringPair;361362 before(async function() {363 await usingEthPlaygrounds(async (helper, privateKey) => {364 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);365366 donor = await privateKey({filename: __filename});367 [alice] = await helper.arrange.createAccounts([50n], donor);368 });369 });370371 itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {372 const owner = await helper.eth.createAccountWithBalance(donor);373 const spender = helper.eth.createAccount();374 const collection = await helper.rft.mintCollection(alice);375 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});376377 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);378 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);379380 const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));381 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));382 });383384 itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {385 const owner = await helper.eth.createAccountWithBalance(donor);386 const spender = await helper.eth.createAccountWithBalance(donor);387 const collection = await helper.rft.mintCollection(alice);388 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});389390 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);391 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);392393 await contract.methods.approve(spender, 100).send({from: owner});394395 const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));396 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));397 });398399 itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {400 const owner = await helper.eth.createAccountWithBalance(donor);401 const receiver = helper.eth.createAccount();402 const collection = await helper.rft.mintCollection(alice);403 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});404405 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);406 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);407408 const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));409 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));410 });411});412413describe('Refungible: Substrate calls', () => {414 let donor: IKeyringPair;415 let alice: IKeyringPair;416417 before(async function() {418 await usingEthPlaygrounds(async (helper, privateKey) => {419 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);420421 donor = await privateKey({filename: __filename});422 [alice] = await helper.arrange.createAccounts([50n], donor);423 });424 });425426 itEth('Events emitted for approve()', async ({helper}) => {427 const receiver = helper.eth.createAccount();428 const collection = await helper.rft.mintCollection(alice);429 const token = await collection.mintToken(alice, 200n);430431 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);432 const contract = helper.ethNativeContract.rftToken(tokenAddress);433434 const events: any = [];435 contract.events.allEvents((_: any, event: any) => {436 events.push(event);437 });438439 expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;440 if (events.length == 0) await helper.wait.newBlocks(1);441 const event = events[0];442443 expect(event.event).to.be.equal('Approval');444 expect(event.address).to.be.equal(tokenAddress);445 expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));446 expect(event.returnValues.spender).to.be.equal(receiver);447 expect(event.returnValues.value).to.be.equal('100');448 });449450 itEth('Events emitted for transferFrom()', async ({helper}) => {451 const [bob] = await helper.arrange.createAccounts([10n], donor);452 const receiver = helper.eth.createAccount();453 const collection = await helper.rft.mintCollection(alice);454 const token = await collection.mintToken(alice, 200n);455 await token.approve(alice, {Substrate: bob.address}, 100n);456457 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);458 const contract = helper.ethNativeContract.rftToken(tokenAddress);459460 const events: any = [];461 contract.events.allEvents((_: any, event: any) => {462 events.push(event);463 });464465 expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver}, 51n)).to.be.true;466 if (events.length == 0) await helper.wait.newBlocks(1);467468 let event = events[0];469 expect(event.event).to.be.equal('Transfer');470 expect(event.address).to.be.equal(tokenAddress);471 expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));472 expect(event.returnValues.to).to.be.equal(receiver);473 expect(event.returnValues.value).to.be.equal('51');474475 event = events[1];476 expect(event.event).to.be.equal('Approval');477 expect(event.address).to.be.equal(tokenAddress);478 expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));479 expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));480 expect(event.returnValues.value).to.be.equal('49');481 });482483 itEth('Events emitted for transfer()', async ({helper}) => {484 const receiver = helper.eth.createAccount();485 const collection = await helper.rft.mintCollection(alice);486 const token = await collection.mintToken(alice, 200n);487488 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);489 const contract = helper.ethNativeContract.rftToken(tokenAddress);490491 const events: any = [];492 contract.events.allEvents((_: any, event: any) => {493 events.push(event);494 });495496 expect(await token.transfer(alice, {Ethereum: receiver}, 51n)).to.be.true;497 if (events.length == 0) await helper.wait.newBlocks(1);498 const event = events[0];499500 expect(event.event).to.be.equal('Transfer');501 expect(event.address).to.be.equal(tokenAddress);502 expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));503 expect(event.returnValues.to).to.be.equal(receiver);504 expect(event.returnValues.value).to.be.equal('51');505 });506});507508describe('ERC 1633 implementation', () => {509 let donor: IKeyringPair;510511 before(async function() {512 await usingEthPlaygrounds(async (helper, privateKey) => {513 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);514515 donor = await privateKey({filename: __filename});516 });517 });518519 itEth('Default parent token address and id', async ({helper}) => {520 const owner = await helper.eth.createAccountWithBalance(donor);521522 const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');523 const collectionContract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);524525 const result = await collectionContract.methods.mint(owner).send();526 const tokenId = result.events.Transfer.returnValues.tokenId;527528 const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);529 const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);530531 expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);532 expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);533 });534});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/>.1617import {Pallets, requirePalletsOrSkip} from '../util';18import {EthUniqueHelper, expect, itEth, usingEthPlaygrounds} from './util';19import {IKeyringPair} from '@polkadot/types/types';20import {Contract} from 'web3-eth-contract';212223describe('Refungible token: Information getting', () => {24 let donor: IKeyringPair;25 let alice: IKeyringPair;2627 before(async function() {28 await usingEthPlaygrounds(async (helper, privateKey) => {29 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);3031 donor = await privateKey({filename: __filename});32 [alice] = await helper.arrange.createAccounts([20n], donor);33 });34 });3536 itEth('totalSupply', async ({helper}) => {37 const caller = await helper.eth.createAccountWithBalance(donor);38 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});39 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});4041 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);42 const totalSupply = await contract.methods.totalSupply().call();43 expect(totalSupply).to.equal('200');44 });4546 itEth('balanceOf', async ({helper}) => {47 const caller = await helper.eth.createAccountWithBalance(donor);48 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});49 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});5051 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);52 const balance = await contract.methods.balanceOf(caller).call();53 expect(balance).to.equal('200');54 });5556 itEth('decimals', async ({helper}) => {57 const caller = await helper.eth.createAccountWithBalance(donor);58 const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'MUON'});59 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: caller});6061 const contract = helper.ethNativeContract.rftTokenById(collection.collectionId, tokenId, caller);62 const decimals = await contract.methods.decimals().call();63 expect(decimals).to.equal('0');64 });65});6667// FIXME: Need erc721 for ReFubgible.68describe('Check ERC721 token URI for ReFungible', () => {69 let donor: IKeyringPair;7071 before(async function() {72 await usingEthPlaygrounds(async (helper, privateKey) => {73 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);7475 donor = await privateKey({filename: __filename});76 });77 });7879 async function setup(helper: EthUniqueHelper, baseUri: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {80 const owner = await helper.eth.createAccountWithBalance(donor);81 const receiver = helper.eth.createAccount();8283 const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Mint collection', 'a', 'b', baseUri);84 const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);8586 const result = await contract.methods.mint(receiver).send();8788 const event = result.events.Transfer;89 const tokenId = event.returnValues.tokenId;90 expect(tokenId).to.be.equal('1');91 expect(event.address).to.be.equal(collectionAddress);92 expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');93 expect(event.returnValues.to).to.be.equal(receiver);9495 if (propertyKey && propertyValue) {96 // Set URL or suffix9798 await contract.methods.setProperties(tokenId, [{key: propertyKey, value: Buffer.from(propertyValue)}]).send();99 }100101 return {contract, nextTokenId: tokenId};102 }103104 itEth('Empty tokenURI', async ({helper}) => {105 const {contract, nextTokenId} = await setup(helper, '');106 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');107 });108109 itEth('TokenURI from url', async ({helper}) => {110 const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URI', 'Token URI');111 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');112 });113114 itEth('TokenURI from baseURI', async ({helper}) => {115 const {contract, nextTokenId} = await setup(helper, 'BaseURI_');116 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_');117 });118119 itEth('TokenURI from baseURI + suffix', async ({helper}) => {120 const suffix = '/some/suffix';121 const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'URISuffix', suffix);122 expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);123 });124});125126describe('Refungible: Plain calls', () => {127 let donor: IKeyringPair;128 let alice: IKeyringPair;129130 before(async function() {131 await usingEthPlaygrounds(async (helper, privateKey) => {132 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);133134 donor = await privateKey({filename: __filename});135 [alice] = await helper.arrange.createAccounts([50n], donor);136 });137 });138139 itEth('Can perform approve()', async ({helper}) => {140 const owner = await helper.eth.createAccountWithBalance(donor);141 const spender = helper.eth.createAccount();142 const collection = await helper.rft.mintCollection(alice);143 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});144145 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);146 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);147148 {149 const result = await contract.methods.approve(spender, 100).send({from: owner});150 const event = result.events.Approval;151 expect(event.address).to.be.equal(tokenAddress);152 expect(event.returnValues.owner).to.be.equal(owner);153 expect(event.returnValues.spender).to.be.equal(spender);154 expect(event.returnValues.value).to.be.equal('100');155 }156157 {158 const allowance = await contract.methods.allowance(owner, spender).call();159 expect(+allowance).to.equal(100);160 }161 });162 163 itEth('Can perform approveCross()', async ({helper}) => {164 const owner = await helper.eth.createAccountWithBalance(donor);165 const spender = helper.eth.createAccount();166 const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];167 const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);168 const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);169 170171 const collection = await helper.rft.mintCollection(alice);172 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});173174 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);175 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);176177 {178 const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});179 const event = result.events.Approval;180 expect(event.address).to.be.equal(tokenAddress);181 expect(event.returnValues.owner).to.be.equal(owner);182 expect(event.returnValues.spender).to.be.equal(spender);183 expect(event.returnValues.value).to.be.equal('100');184 }185186 {187 const allowance = await contract.methods.allowance(owner, spender).call();188 expect(+allowance).to.equal(100);189 }190 191 192 {193 const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});194 const event = result.events.Approval;195 expect(event.address).to.be.equal(tokenAddress);196 expect(event.returnValues.owner).to.be.equal(owner);197 expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));198 expect(event.returnValues.value).to.be.equal('100');199 }200201 {202 const allowance = await collection.getTokenApprovedPieces(tokenId, {Ethereum: owner}, {Substrate: spenderSub.address});203 expect(allowance).to.equal(100n);204 }205 206 {207 //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()208 }209 });210 211 itEth('Can perform transferFrom()', async ({helper}) => {212 const owner = await helper.eth.createAccountWithBalance(donor);213 const spender = await helper.eth.createAccountWithBalance(donor);214 const receiver = helper.eth.createAccount();215 const collection = await helper.rft.mintCollection(alice);216 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});217218 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);219 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);220221 await contract.methods.approve(spender, 100).send();222223 {224 const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});225 let event = result.events.Transfer;226 expect(event.address).to.be.equal(tokenAddress);227 expect(event.returnValues.from).to.be.equal(owner);228 expect(event.returnValues.to).to.be.equal(receiver);229 expect(event.returnValues.value).to.be.equal('49');230231 event = result.events.Approval;232 expect(event.address).to.be.equal(tokenAddress);233 expect(event.returnValues.owner).to.be.equal(owner);234 expect(event.returnValues.spender).to.be.equal(spender);235 expect(event.returnValues.value).to.be.equal('51');236 }237238 {239 const balance = await contract.methods.balanceOf(receiver).call();240 expect(+balance).to.equal(49);241 }242243 {244 const balance = await contract.methods.balanceOf(owner).call();245 expect(+balance).to.equal(151);246 }247 });248 249 itEth('Can perform transferFromCross()', async ({helper}) => {250 const owner = await helper.eth.createAccountWithBalance(donor);251 const ownerCross = helper.ethCrossAccount.fromAddress(owner);252 const spender = await helper.eth.createAccountWithBalance(donor);253 const receiver = helper.eth.createAccount();254 const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];255 const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);256 const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);257 258 const collection = await helper.rft.mintCollection(alice);259 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});260261 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);262 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);263264 await contract.methods.approve(spender, 100).send({from: owner});265 266 {267 const result = await contract.methods.transferFromCross(ownerCross, receiverCrossEth, 49).send({from: spender});268 let event = result.events.Transfer;269 expect(event.address).to.be.equal(tokenAddress);270 expect(event.returnValues.from).to.be.equal(owner);271 expect(event.returnValues.to).to.be.equal(receiver);272 expect(event.returnValues.value).to.be.equal('49');273274 event = result.events.Approval;275 expect(event.address).to.be.equal(tokenAddress);276 expect(event.returnValues.owner).to.be.equal(owner);277 expect(event.returnValues.spender).to.be.equal(spender);278 expect(event.returnValues.value).to.be.equal('51');279 }280281 {282 const balance = await contract.methods.balanceOf(receiver).call();283 expect(+balance).to.equal(49);284 }285286 {287 const balance = await contract.methods.balanceOf(owner).call();288 expect(+balance).to.equal(151);289 }290 291 {292 const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender});293 let event = result.events.Transfer;294 expect(event.address).to.be.equal(tokenAddress);295 expect(event.returnValues.from).to.be.equal(owner);296 expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));297 expect(event.returnValues.value).to.be.equal('51');298299 event = result.events.Approval;300 expect(event.address).to.be.equal(tokenAddress);301 expect(event.returnValues.owner).to.be.equal(owner);302 expect(event.returnValues.spender).to.be.equal(spender);303 expect(event.returnValues.value).to.be.equal('0');304 }305306 {307 const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});308 expect(balance).to.equal(51n);309 }310311 {312 const balance = await contract.methods.balanceOf(owner).call();313 expect(+balance).to.equal(100);314 }315 });316317 itEth('Can perform transfer()', async ({helper}) => {318 const owner = await helper.eth.createAccountWithBalance(donor);319 const receiver = helper.eth.createAccount();320 const collection = await helper.rft.mintCollection(alice);321 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});322323 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);324 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);325326 {327 const result = await contract.methods.transfer(receiver, 50).send({from: owner});328 const event = result.events.Transfer;329 expect(event.address).to.be.equal(tokenAddress);330 expect(event.returnValues.from).to.be.equal(owner);331 expect(event.returnValues.to).to.be.equal(receiver);332 expect(event.returnValues.value).to.be.equal('50');333 }334335 {336 const balance = await contract.methods.balanceOf(owner).call();337 expect(+balance).to.equal(150);338 }339340 {341 const balance = await contract.methods.balanceOf(receiver).call();342 expect(+balance).to.equal(50);343 }344 });345 346 [347 'transfer',348 // 'transferCross', // TODO349 ].map(testCase => 350 itEth(`Cannot ${testCase}() non-owned token`, async ({helper}) => {351 const owner = await helper.eth.createAccountWithBalance(donor);352 const receiver = await helper.eth.createAccountWithBalance(donor);353 const collection = await helper.rft.mintCollection(alice);354 const rftOwner = await collection.mintToken(alice, 10n, {Ethereum: owner});355 const rftReceiver = await collection.mintToken(alice, 10n, {Ethereum: receiver});356 const tokenIdNonExist = 9999999;357 358 const tokenAddress1 = helper.ethAddress.fromTokenId(collection.collectionId, rftOwner.tokenId);359 const tokenAddress2 = helper.ethAddress.fromTokenId(collection.collectionId, rftReceiver.tokenId);360 const tokenAddressNonExist = helper.ethAddress.fromTokenId(collection.collectionId, tokenIdNonExist);361 const tokenEvmOwner = helper.ethNativeContract.rftToken(tokenAddress1, owner);362 const tokenEvmReceiver = helper.ethNativeContract.rftToken(tokenAddress2, owner);363 const tokenEvmNonExist = helper.ethNativeContract.rftToken(tokenAddressNonExist, owner);364 365 // 1. Can transfer zero amount (EIP-20):366 await tokenEvmOwner.methods[testCase](receiver, 0).send({from: owner});367 // 2. Cannot transfer non-owned token:368 await expect(tokenEvmReceiver.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;369 await expect(tokenEvmReceiver.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;370 // 3. Cannot transfer non-existing token:371 await expect(tokenEvmNonExist.methods[testCase](owner, 0).send({from: owner})).to.be.rejected;372 await expect(tokenEvmNonExist.methods[testCase](owner, 5).send({from: owner})).to.be.rejected;373374 // 4. Storage is not corrupted:375 expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);376 expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);377 expect(await helper.rft.getTokenTop10Owners(collection.collectionId, tokenIdNonExist)).to.deep.eq([]); // TODO378379 // 4.1 Tokens can be transferred:380 await tokenEvmOwner.methods[testCase](receiver, 10).send({from: owner});381 await tokenEvmReceiver.methods[testCase](owner, 10).send({from: receiver});382 expect(await rftOwner.getTop10Owners()).to.deep.eq([{Ethereum: receiver.toLowerCase()}]);383 expect(await rftReceiver.getTop10Owners()).to.deep.eq([{Ethereum: owner.toLowerCase()}]);384 }));385386 itEth('Can perform transferCross()', async ({helper}) => {387 const owner = await helper.eth.createAccountWithBalance(donor);388 const receiver = helper.eth.createAccount();389 const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];390 const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);391 const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);392 const collection = await helper.rft.mintCollection(alice);393 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});394395 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);396 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);397398 {399 const result = await contract.methods.transferCross(receiverCrossEth, 50).send({from: owner});400 const event = result.events.Transfer;401 expect(event.address).to.be.equal(tokenAddress);402 expect(event.returnValues.from).to.be.equal(owner);403 expect(event.returnValues.to).to.be.equal(receiver);404 expect(event.returnValues.value).to.be.equal('50');405 }406407 {408 const balance = await contract.methods.balanceOf(owner).call();409 expect(+balance).to.equal(150);410 }411412 {413 const balance = await contract.methods.balanceOf(receiver).call();414 expect(+balance).to.equal(50);415 }416 417 {418 const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner});419 const event = result.events.Transfer;420 expect(event.address).to.be.equal(tokenAddress);421 expect(event.returnValues.from).to.be.equal(owner);422 expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));423 expect(event.returnValues.value).to.be.equal('50');424 }425426 {427 const balance = await contract.methods.balanceOf(owner).call();428 expect(+balance).to.equal(100);429 }430431 {432 const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});433 expect(balance).to.equal(50n);434 }435 });436 itEth('Can perform repartition()', async ({helper}) => {437 const owner = await helper.eth.createAccountWithBalance(donor);438 const receiver = await helper.eth.createAccountWithBalance(donor);439 const collection = await helper.rft.mintCollection(alice);440 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});441442 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);443 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);444445 await contract.methods.repartition(200).send({from: owner});446 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200);447 await contract.methods.transfer(receiver, 110).send({from: owner});448 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90);449 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110);450451 await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; // Transaction is reverted452453 await contract.methods.transfer(receiver, 90).send({from: owner});454 expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(0);455 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(200);456457 await contract.methods.repartition(150).send({from: receiver});458 await expect(contract.methods.transfer(owner, 160).send({from: receiver})).to.eventually.be.rejected; // Transaction is reverted459 expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(150);460 });461462 itEth('Can repartition with increased amount', async ({helper}) => {463 const owner = await helper.eth.createAccountWithBalance(donor);464 const collection = await helper.rft.mintCollection(alice);465 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});466467 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);468 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);469470 const result = await contract.methods.repartition(200).send();471472 const event = result.events.Transfer;473 expect(event.address).to.be.equal(tokenAddress);474 expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');475 expect(event.returnValues.to).to.be.equal(owner);476 expect(event.returnValues.value).to.be.equal('100');477 });478479 itEth('Can repartition with decreased amount', async ({helper}) => {480 const owner = await helper.eth.createAccountWithBalance(donor);481 const collection = await helper.rft.mintCollection(alice);482 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});483484 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);485 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);486487 const result = await contract.methods.repartition(50).send();488 const event = result.events.Transfer;489 expect(event.address).to.be.equal(tokenAddress);490 expect(event.returnValues.from).to.be.equal(owner);491 expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');492 expect(event.returnValues.value).to.be.equal('50');493 });494495 itEth('Receiving Transfer event on burning into full ownership', async ({helper}) => {496 const caller = await helper.eth.createAccountWithBalance(donor);497 const receiver = await helper.eth.createAccountWithBalance(donor);498 const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(caller, 'Devastation', '6', '6');499 const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller);500501 const result = await contract.methods.mint(caller).send();502 const tokenId = result.events.Transfer.returnValues.tokenId;503 const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);504 const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, caller);505506 await tokenContract.methods.repartition(2).send();507 await tokenContract.methods.transfer(receiver, 1).send();508509 const events: any = [];510 contract.events.allEvents((_: any, event: any) => {511 events.push(event);512 });513 await tokenContract.methods.burnFrom(caller, 1).send();514515 if (events.length == 0) await helper.wait.newBlocks(1);516 const event = events[0];517 expect(event.address).to.be.equal(collectionAddress);518 expect(event.returnValues.from).to.be.equal('0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF');519 expect(event.returnValues.to).to.be.equal(receiver);520 expect(event.returnValues.tokenId).to.be.equal(tokenId);521 });522 523 itEth('Can perform burnFromCross()', async ({helper}) => {524 const owner = await helper.eth.createAccountWithBalance(donor);525 const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0];526 const ownerCross = helper.ethCrossAccount.fromAddress(owner);527 const spender = await helper.eth.createAccountWithBalance(donor);528 529 const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);530 const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub);531532 const collection = await helper.rft.mintCollection(alice);533 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});534 535536 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);537 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);538539 {540 await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});541 542 await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;543 await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;544 expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');545 }546 {547 const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address});548 await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n);549 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);550 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);551 552 await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled;553 await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected;554 expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n);555 }556 });557});558559describe('Refungible: Fees', () => {560 let donor: IKeyringPair;561 let alice: IKeyringPair;562563 before(async function() {564 await usingEthPlaygrounds(async (helper, privateKey) => {565 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);566567 donor = await privateKey({filename: __filename});568 [alice] = await helper.arrange.createAccounts([50n], donor);569 });570 });571572 itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {573 const owner = await helper.eth.createAccountWithBalance(donor);574 const spender = helper.eth.createAccount();575 const collection = await helper.rft.mintCollection(alice);576 const {tokenId} = await collection.mintToken(alice, 100n, {Ethereum: owner});577578 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);579 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);580581 const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));582 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));583 });584585 itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {586 const owner = await helper.eth.createAccountWithBalance(donor);587 const spender = await helper.eth.createAccountWithBalance(donor);588 const collection = await helper.rft.mintCollection(alice);589 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});590591 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);592 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);593594 await contract.methods.approve(spender, 100).send({from: owner});595596 const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));597 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));598 });599600 itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {601 const owner = await helper.eth.createAccountWithBalance(donor);602 const receiver = helper.eth.createAccount();603 const collection = await helper.rft.mintCollection(alice);604 const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});605606 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);607 const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);608609 const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));610 expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));611 });612});613614describe('Refungible: Substrate calls', () => {615 let donor: IKeyringPair;616 let alice: IKeyringPair;617618 before(async function() {619 await usingEthPlaygrounds(async (helper, privateKey) => {620 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);621622 donor = await privateKey({filename: __filename});623 [alice] = await helper.arrange.createAccounts([50n], donor);624 });625 });626627 itEth('Events emitted for approve()', async ({helper}) => {628 const receiver = helper.eth.createAccount();629 const collection = await helper.rft.mintCollection(alice);630 const token = await collection.mintToken(alice, 200n);631632 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);633 const contract = helper.ethNativeContract.rftToken(tokenAddress);634635 const events: any = [];636 contract.events.allEvents((_: any, event: any) => {637 events.push(event);638 });639640 expect(await token.approve(alice, {Ethereum: receiver}, 100n)).to.be.true;641 if (events.length == 0) await helper.wait.newBlocks(1);642 const event = events[0];643644 expect(event.event).to.be.equal('Approval');645 expect(event.address).to.be.equal(tokenAddress);646 expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));647 expect(event.returnValues.spender).to.be.equal(receiver);648 expect(event.returnValues.value).to.be.equal('100');649 });650651 itEth('Events emitted for transferFrom()', async ({helper}) => {652 const [bob] = await helper.arrange.createAccounts([10n], donor);653 const receiver = helper.eth.createAccount();654 const collection = await helper.rft.mintCollection(alice);655 const token = await collection.mintToken(alice, 200n);656 await token.approve(alice, {Substrate: bob.address}, 100n);657658 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);659 const contract = helper.ethNativeContract.rftToken(tokenAddress);660661 const events: any = [];662 contract.events.allEvents((_: any, event: any) => {663 events.push(event);664 });665666 expect(await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver}, 51n)).to.be.true;667 if (events.length == 0) await helper.wait.newBlocks(1);668669 let event = events[0];670 expect(event.event).to.be.equal('Transfer');671 expect(event.address).to.be.equal(tokenAddress);672 expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));673 expect(event.returnValues.to).to.be.equal(receiver);674 expect(event.returnValues.value).to.be.equal('51');675676 event = events[1];677 expect(event.event).to.be.equal('Approval');678 expect(event.address).to.be.equal(tokenAddress);679 expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));680 expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));681 expect(event.returnValues.value).to.be.equal('49');682 });683684 itEth('Events emitted for transfer()', async ({helper}) => {685 const receiver = helper.eth.createAccount();686 const collection = await helper.rft.mintCollection(alice);687 const token = await collection.mintToken(alice, 200n);688689 const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);690 const contract = helper.ethNativeContract.rftToken(tokenAddress);691692 const events: any = [];693 contract.events.allEvents((_: any, event: any) => {694 events.push(event);695 });696697 expect(await token.transfer(alice, {Ethereum: receiver}, 51n)).to.be.true;698 if (events.length == 0) await helper.wait.newBlocks(1);699 const event = events[0];700701 expect(event.event).to.be.equal('Transfer');702 expect(event.address).to.be.equal(tokenAddress);703 expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));704 expect(event.returnValues.to).to.be.equal(receiver);705 expect(event.returnValues.value).to.be.equal('51');706 });707});708709describe('ERC 1633 implementation', () => {710 let donor: IKeyringPair;711712 before(async function() {713 await usingEthPlaygrounds(async (helper, privateKey) => {714 requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);715716 donor = await privateKey({filename: __filename});717 });718 });719720 itEth('Default parent token address and id', async ({helper}) => {721 const owner = await helper.eth.createAccountWithBalance(donor);722723 const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Sands', '', 'GRAIN');724 const collectionContract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);725726 const result = await collectionContract.methods.mint(owner).send();727 const tokenId = result.events.Transfer.returnValues.tokenId;728729 const tokenAddress = helper.ethAddress.fromTokenId(collectionId, tokenId);730 const tokenContract = helper.ethNativeContract.rftToken(tokenAddress, owner);731732 expect(await tokenContract.methods.parentToken().call()).to.be.equal(collectionAddress);733 expect(await tokenContract.methods.parentTokenId().call()).to.be.equal(tokenId);734 });735});tests/src/interfaces/augment-api-rpc.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -16,7 +16,7 @@
import type { BlockHash } from '@polkadot/types/interfaces/chain';
import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import type { CodeUploadRequest, CodeUploadResult, ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequestV1 } from '@polkadot/types/interfaces/contracts';
+import type { CodeUploadRequest, CodeUploadResult, ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts';
import type { BlockStats } from '@polkadot/types/interfaces/dev';
import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
import type { EthAccount, EthCallRequest, EthFeeHistory, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';
@@ -24,7 +24,7 @@
import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
import type { MmrLeafBatchProof, MmrLeafProof } from '@polkadot/types/interfaces/mmr';
import type { StorageKind } from '@polkadot/types/interfaces/offchain';
-import type { FeeDetails, RuntimeDispatchInfoV1 } from '@polkadot/types/interfaces/payment';
+import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
import type { AccountId, AccountId32, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
import type { MigrationStatusResult, ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
@@ -174,7 +174,7 @@
* @deprecated Use the runtime interface `api.call.contractsApi.instantiate` instead
* Instantiate a new contract
**/
- instantiate: AugmentedRpc<(request: InstantiateRequestV1 | { origin?: any; value?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
+ instantiate: AugmentedRpc<(request: InstantiateRequest | { origin?: any; value?: any; gasLimit?: any; storageDepositLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
/**
* @deprecated Not available in newer versions of the contracts interfaces
* Returns the projected time a given contract will be able to sustain paying its rent
@@ -426,15 +426,13 @@
};
payment: {
/**
- * @deprecated Use `api.call.transactionPaymentApi.queryFeeDetails` instead
* Query the detailed fee of a given encoded extrinsic
**/
queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<FeeDetails>>;
/**
- * @deprecated Use `api.call.transactionPaymentApi.queryInfo` instead
* Retrieves the fee information for an encoded extrinsic
**/
- queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfoV1>>;
+ queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfo>>;
};
rmrk: {
/**
tests/src/interfaces/augment-api-runtime.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-runtime.ts
+++ b/tests/src/interfaces/augment-api-runtime.ts
@@ -6,7 +6,7 @@
import '@polkadot/api-base/types/calls';
import type { ApiTypes, AugmentedCall, DecoratedCallBase } from '@polkadot/api-base/types';
-import type { Bytes, Null, Option, Result, U256, Vec, bool, u256, u32, u64 } from '@polkadot/types-codec';
+import type { Bytes, Null, Option, Result, U256, Vec, bool, u256, u64 } from '@polkadot/types-codec';
import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
import type { CheckInherentsResult, InherentData } from '@polkadot/types/interfaces/blockbuilder';
import type { BlockHash } from '@polkadot/types/interfaces/chain';
@@ -16,7 +16,6 @@
import type { EvmAccount, EvmCallInfo, EvmCreateInfo } from '@polkadot/types/interfaces/evm';
import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
import type { OpaqueMetadata } from '@polkadot/types/interfaces/metadata';
-import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
import type { AccountId, Block, H160, H256, Header, Index, KeyTypeId, Permill, SlotDuration } from '@polkadot/types/interfaces/runtime';
import type { RuntimeVersion } from '@polkadot/types/interfaces/state';
import type { ApplyExtrinsicResult, DispatchError } from '@polkadot/types/interfaces/system';
@@ -224,21 +223,6 @@
* Validate the transaction.
**/
validateTransaction: AugmentedCall<ApiType, (source: TransactionSource | 'InBlock' | 'Local' | 'External' | number | Uint8Array, tx: Extrinsic | IExtrinsic | string | Uint8Array, blockHash: BlockHash | string | Uint8Array) => Observable<TransactionValidity>>;
- /**
- * Generic call
- **/
- [key: string]: DecoratedCallBase<ApiType>;
- };
- /** 0x37c8bb1350a9a2a8/2 */
- transactionPaymentApi: {
- /**
- * The transaction fee details
- **/
- queryFeeDetails: AugmentedCall<ApiType, (uxt: Extrinsic | IExtrinsic | string | Uint8Array, len: u32 | AnyNumber | Uint8Array) => Observable<FeeDetails>>;
- /**
- * The transaction info
- **/
- queryInfo: AugmentedCall<ApiType, (uxt: Extrinsic | IExtrinsic | string | Uint8Array, len: u32 | AnyNumber | Uint8Array) => Observable<RuntimeDispatchInfo>>;
/**
* Generic call
**/
tests/src/interfaces/augment-types.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-types.ts
+++ b/tests/src/interfaces/augment-types.ts
@@ -24,7 +24,7 @@
import type { StatementKind } from '@polkadot/types/interfaces/claims';
import type { CollectiveOrigin, MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective';
import type { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus';
-import type { AliveContractInfo, CodeHash, CodeSource, CodeUploadRequest, CodeUploadResult, CodeUploadResultValue, ContractCallFlags, ContractCallRequest, ContractExecResult, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractExecResultU64, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractInstantiateResultTo299, ContractInstantiateResultU64, ContractReturnFlags, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateRequestV1, InstantiateRequestV2, InstantiateReturnValue, InstantiateReturnValueOk, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, StorageDeposit, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts';
+import type { AliveContractInfo, CodeHash, CodeSource, CodeUploadRequest, CodeUploadResult, CodeUploadResultValue, ContractCallFlags, ContractCallRequest, ContractExecResult, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractInstantiateResultTo299, ContractReturnFlags, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateRequestV1, InstantiateRequestV2, InstantiateReturnValue, InstantiateReturnValueOk, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, StorageDeposit, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts';
import type { ContractConstructorSpecLatest, ContractConstructorSpecV0, ContractConstructorSpecV1, ContractConstructorSpecV2, ContractConstructorSpecV3, ContractContractSpecV0, ContractContractSpecV1, ContractContractSpecV2, ContractContractSpecV3, ContractContractSpecV4, ContractCryptoHasher, ContractDiscriminant, ContractDisplayName, ContractEventParamSpecLatest, ContractEventParamSpecV0, ContractEventParamSpecV2, ContractEventSpecLatest, ContractEventSpecV0, ContractEventSpecV1, ContractEventSpecV2, ContractLayoutArray, ContractLayoutCell, ContractLayoutEnum, ContractLayoutHash, ContractLayoutHashingStrategy, ContractLayoutKey, ContractLayoutStruct, ContractLayoutStructField, ContractMessageParamSpecLatest, ContractMessageParamSpecV0, ContractMessageParamSpecV2, ContractMessageSpecLatest, ContractMessageSpecV0, ContractMessageSpecV1, ContractMessageSpecV2, ContractMetadata, ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1, ContractMetadataV2, ContractMetadataV3, ContractMetadataV4, ContractProject, ContractProjectContract, ContractProjectInfo, ContractProjectSource, ContractProjectV0, ContractSelector, ContractStorageLayout, ContractTypeSpec } from '@polkadot/types/interfaces/contractsAbi';
import type { FundIndex, FundInfo, LastContribution, TrieIndex } from '@polkadot/types/interfaces/crowdloan';
import type { CollationInfo, CollationInfoV1, ConfigData, MessageId, OverweightIndex, PageCounter, PageIndexData } from '@polkadot/types/interfaces/cumulus';
@@ -47,7 +47,7 @@
import type { StorageKind } from '@polkadot/types/interfaces/offchain';
import type { DeferredOffenceOf, Kind, OffenceDetails, Offender, OpaqueTimeSlot, ReportIdOf, Reporter } from '@polkadot/types/interfaces/offences';
import type { AbridgedCandidateReceipt, AbridgedHostConfiguration, AbridgedHrmpChannel, AssignmentId, AssignmentKind, AttestedCandidate, AuctionIndex, AuthorityDiscoveryId, AvailabilityBitfield, AvailabilityBitfieldRecord, BackedCandidate, Bidder, BufferedSessionChange, CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateInfo, CandidatePendingAvailability, CandidateReceipt, CollatorId, CollatorSignature, CommittedCandidateReceipt, CoreAssignment, CoreIndex, CoreOccupied, CoreState, DisputeLocation, DisputeResult, DisputeState, DisputeStatement, DisputeStatementSet, DoubleVoteReport, DownwardMessage, ExplicitDisputeStatement, GlobalValidationData, GlobalValidationSchedule, GroupIndex, GroupRotationInfo, HeadData, HostConfiguration, HrmpChannel, HrmpChannelId, HrmpOpenChannelRequest, InboundDownwardMessage, InboundHrmpMessage, InboundHrmpMessages, IncomingParachain, IncomingParachainDeploy, IncomingParachainFixed, InvalidDisputeStatementKind, LeasePeriod, LeasePeriodOf, LocalValidationData, MessageIngestionType, MessageQueueChain, MessagingStateSnapshot, MessagingStateSnapshotEgressEntry, MultiDisputeStatementSet, NewBidder, OccupiedCore, OccupiedCoreAssumption, OldV1SessionInfo, OutboundHrmpMessage, ParaGenesisArgs, ParaId, ParaInfo, ParaLifecycle, ParaPastCodeMeta, ParaScheduling, ParaValidatorIndex, ParachainDispatchOrigin, ParachainInherentData, ParachainProposal, ParachainsInherentData, ParathreadClaim, ParathreadClaimQueue, ParathreadEntry, PersistedValidationData, PvfCheckStatement, QueuedParathread, RegisteredParachainInfo, RelayBlockNumber, RelayChainBlockNumber, RelayChainHash, RelayHash, Remark, ReplacementTimes, Retriable, ScheduledCore, Scheduling, ScrapedOnChainVotes, ServiceQuality, SessionInfo, SessionInfoValidatorGroup, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SigningContext, SlotRange, SlotRange10, Statement, SubId, SystemInherentData, TransientValidationData, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidationData, ValidationDataType, ValidationFunctionParams, ValidatorSignature, ValidityAttestation, VecInboundHrmpMessage, WinnersData, WinnersData10, WinnersDataTuple, WinnersDataTuple10, WinningData, WinningData10, WinningDataEntry } from '@polkadot/types/interfaces/parachains';
-import type { FeeDetails, InclusionFee, RuntimeDispatchInfo, RuntimeDispatchInfoV1, RuntimeDispatchInfoV2 } from '@polkadot/types/interfaces/payment';
+import type { FeeDetails, InclusionFee, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
import type { Approvals } from '@polkadot/types/interfaces/poll';
import type { ProxyAnnouncement, ProxyDefinition, ProxyType } from '@polkadot/types/interfaces/proxy';
import type { AccountStatus, AccountValidity } from '@polkadot/types/interfaces/purchase';
@@ -273,12 +273,10 @@
ContractExecResultTo255: ContractExecResultTo255;
ContractExecResultTo260: ContractExecResultTo260;
ContractExecResultTo267: ContractExecResultTo267;
- ContractExecResultU64: ContractExecResultU64;
ContractInfo: ContractInfo;
ContractInstantiateResult: ContractInstantiateResult;
ContractInstantiateResultTo267: ContractInstantiateResultTo267;
ContractInstantiateResultTo299: ContractInstantiateResultTo299;
- ContractInstantiateResultU64: ContractInstantiateResultU64;
ContractLayoutArray: ContractLayoutArray;
ContractLayoutCell: ContractLayoutCell;
ContractLayoutEnum: ContractLayoutEnum;
@@ -1059,8 +1057,6 @@
RpcMethods: RpcMethods;
RuntimeDbWeight: RuntimeDbWeight;
RuntimeDispatchInfo: RuntimeDispatchInfo;
- RuntimeDispatchInfoV1: RuntimeDispatchInfoV1;
- RuntimeDispatchInfoV2: RuntimeDispatchInfoV2;
RuntimeVersion: RuntimeVersion;
RuntimeVersionApi: RuntimeVersionApi;
RuntimeVersionPartial: RuntimeVersionPartial;