git.delta.rocks / unique-network / refs/commits / 21ff2d2646c6

difftreelog

Merge pull request #750 from UniqueNetwork/feature/cross-methods-refungible-erc20-support

ut-akuznetsov2022-12-16parents: #dfa407a #8ba2075.patch.diff
in: master
added cross methods: `burnFromCross` , `transferCross`, `approveCorss…

9 files changed

modifiedpallets/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> {
modifiedpallets/refungible/src/stubs/UniqueRefungibleToken.rawdiffbeforeafterboth

binary blob — no preview

modifiedpallets/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
modifiedtests/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"
   }
 ]
modifiedtests/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
modifiedtests/src/eth/reFungibleToken.test.tsdiffbeforeafterboth
before · tests/src/eth/reFungibleToken.test.ts
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  });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});
modifiedtests/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: {
       /**
modifiedtests/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
        **/
modifiedtests/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;