difftreelog
Merge pull request #483 from UniqueNetwork/feature/mint-for-fungible-token
in: master
12 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2169,7 +2169,7 @@
[[package]]
name = "evm-coder"
-version = "0.1.1"
+version = "0.1.3"
dependencies = [
"ethereum",
"evm-coder-procedural",
@@ -2178,6 +2178,7 @@
"hex-literal",
"impl-trait-for-tuples",
"primitive-types",
+ "sp-std",
]
[[package]]
@@ -5748,7 +5749,7 @@
[[package]]
name = "pallet-fungible"
-version = "0.1.4"
+version = "0.1.5"
dependencies = [
"ethereum",
"evm-coder",
crates/evm-coder/CHANGELOG.mddiffbeforeafterboth--- a/crates/evm-coder/CHANGELOG.md
+++ b/crates/evm-coder/CHANGELOG.md
@@ -2,6 +2,12 @@
All notable changes to this project will be documented in this file.
+## [0.1.3] - 2022-08-29
+
+### Fixed
+
+ - Parsing simple values.
+
<!-- bureaucrate goes here -->
## [v0.1.2] 2022-08-19
@@ -21,4 +27,4 @@
- build: Upgrade polkadot to v0.9.26 85515e54c4ca1b82a2630034e55dcc804c643bf8
-- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b
\ No newline at end of file
+- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b
crates/evm-coder/Cargo.tomldiffbeforeafterboth--- a/crates/evm-coder/Cargo.toml
+++ b/crates/evm-coder/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "evm-coder"
-version = "0.1.1"
+version = "0.1.3"
license = "GPLv3"
edition = "2021"
@@ -11,8 +11,9 @@
primitive-types = { version = "0.11.1", default-features = false }
# Evm doesn't have reexports for log and others
ethereum = { version = "0.12.0", default-features = false }
+sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
# Error types for execution
-evm-core = { default-features = false, git = "https://github.com/uniquenetwork/evm", branch = "unique-polkadot-v0.9.27" }
+evm-core = { default-features = false , git = "https://github.com/uniquenetwork/evm", branch = "unique-polkadot-v0.9.27" }
# We have tuple-heavy code in solidity.rs
impl-trait-for-tuples = "0.2.2"
crates/evm-coder/src/abi.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -31,6 +31,10 @@
const ABI_ALIGNMENT: usize = 32;
+trait TypeHelper {
+ fn is_dynamic() -> bool;
+}
+
/// View into RLP data, which provides method to read typed items from it
#[derive(Clone)]
pub struct AbiReader<'i> {
@@ -77,8 +81,8 @@
return Err(Error::Error(ExitError::OutOfOffset));
}
let mut block = [0; S];
- // Verify padding is empty
- if !buf[pad_start..pad_size].iter().all(|&v| v == 0) {
+ let is_pad_zeroed = buf[pad_start..pad_size].iter().all(|&v| v == 0);
+ if !is_pad_zeroed {
return Err(Error::Error(ExitError::InvalidRange));
}
block.copy_from_slice(&buf[block_start..block_size]);
@@ -133,7 +137,7 @@
/// Read [`Vec<u8>`] at current position, then advance
pub fn bytes(&mut self) -> Result<Vec<u8>> {
- let mut subresult = self.subresult()?;
+ let mut subresult = self.subresult(None)?;
let length = subresult.uint32()? as usize;
if subresult.buf.len() < subresult.offset + length {
return Err(Error::Error(ExitError::OutOfOffset));
@@ -179,15 +183,26 @@
}
/// Slice recursive buffer, advance one word for buffer offset
- fn subresult(&mut self) -> Result<AbiReader<'i>> {
- let offset = self.uint32()? as usize;
+ /// If `size` is [`None`] then [`Self::offset`] and [`Self::subresult_offset`] evals from [`Self::buf`].
+ fn subresult(&mut self, size: Option<usize>) -> Result<AbiReader<'i>> {
+ let subresult_offset = self.subresult_offset;
+ let offset = if let Some(size) = size {
+ self.offset += size;
+ self.subresult_offset += size;
+ 0
+ } else {
+ self.uint32()? as usize
+ };
+
if offset + self.subresult_offset > self.buf.len() {
return Err(Error::Error(ExitError::InvalidRange));
}
+
+ let new_offset = offset + subresult_offset;
Ok(AbiReader {
buf: self.buf,
- subresult_offset: offset + self.subresult_offset,
- offset: offset + self.subresult_offset,
+ subresult_offset: new_offset,
+ offset: new_offset,
})
}
@@ -318,28 +333,40 @@
pub trait AbiRead<T> {
/// Read item from current position, advanding decoder
fn abi_read(&mut self) -> Result<T>;
+
+ /// Size for type aligned to [`ABI_ALIGNMENT`].
+ fn size() -> usize;
}
macro_rules! impl_abi_readable {
- ($ty:ty, $method:ident) => {
+ ($ty:ty, $method:ident, $dynamic:literal) => {
+ impl TypeHelper for $ty {
+ fn is_dynamic() -> bool {
+ $dynamic
+ }
+ }
impl AbiRead<$ty> for AbiReader<'_> {
fn abi_read(&mut self) -> Result<$ty> {
self.$method()
}
+
+ fn size() -> usize {
+ ABI_ALIGNMENT
+ }
}
};
}
-impl_abi_readable!(u8, uint8);
-impl_abi_readable!(u32, uint32);
-impl_abi_readable!(u64, uint64);
-impl_abi_readable!(u128, uint128);
-impl_abi_readable!(U256, uint256);
-impl_abi_readable!([u8; 4], bytes4);
-impl_abi_readable!(H160, address);
-impl_abi_readable!(Vec<u8>, bytes);
-impl_abi_readable!(bool, bool);
-impl_abi_readable!(string, string);
+impl_abi_readable!(u8, uint8, false);
+impl_abi_readable!(u32, uint32, false);
+impl_abi_readable!(u64, uint64, false);
+impl_abi_readable!(u128, uint128, false);
+impl_abi_readable!(U256, uint256, false);
+impl_abi_readable!([u8; 4], bytes4, false);
+impl_abi_readable!(H160, address, false);
+impl_abi_readable!(Vec<u8>, bytes, true);
+impl_abi_readable!(bool, bool, true);
+impl_abi_readable!(string, string, true);
mod sealed {
/// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
@@ -355,7 +382,7 @@
Self: AbiRead<R>,
{
fn abi_read(&mut self) -> Result<Vec<R>> {
- let mut sub = self.subresult()?;
+ let mut sub = self.subresult(None)?;
let size = sub.uint32()? as usize;
sub.subresult_offset = sub.offset;
let mut out = Vec::with_capacity(size);
@@ -364,21 +391,41 @@
}
Ok(out)
}
+
+ fn size() -> usize {
+ ABI_ALIGNMENT
+ }
}
macro_rules! impl_tuples {
($($ident:ident)+) => {
+ impl<$($ident: TypeHelper,)+> TypeHelper for ($($ident,)+) {
+ fn is_dynamic() -> bool {
+ false
+ $(
+ || <$ident>::is_dynamic()
+ )*
+ }
+ }
impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
where
- $(Self: AbiRead<$ident>),+
+ $(
+ Self: AbiRead<$ident>,
+ )+
+ ($($ident,)+): TypeHelper,
{
fn abi_read(&mut self) -> Result<($($ident,)+)> {
- let mut subresult = self.subresult()?;
+ let size = if !<($($ident,)+)>::is_dynamic() { Some(<Self as AbiRead<($($ident,)+)>>::size()) } else { None };
+ let mut subresult = self.subresult(size)?;
Ok((
$(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+
))
}
+
+ fn size() -> usize {
+ 0 $(+ <AbiReader<'_> as AbiRead<$ident>>::size())+
+ }
}
#[allow(non_snake_case)]
impl<$($ident),+> AbiWrite for &($($ident,)+)
@@ -535,7 +582,7 @@
assert_eq!(encoded, alternative_encoded);
let mut decoder = AbiReader::new(&encoded);
- assert_eq!(decoder.bool().unwrap(), true);
+ assert!(decoder.bool().unwrap());
assert_eq!(decoder.string().unwrap(), "test");
}
@@ -604,4 +651,49 @@
]
);
}
+
+ #[test]
+ fn parse_vec_with_simple_type() {
+ use crate::types::address;
+ use primitive_types::{H160, U256};
+
+ let (call, mut decoder) = AbiReader::new_call(&hex!(
+ "
+ 1ACF2D55
+ 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[]
+ 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[]
+
+ 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address
+ 000000000000000000000000000000000000000000000000000000000000000A // uint256
+
+ 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address
+ 0000000000000000000000000000000000000000000000000000000000000014 // uint256
+
+ 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address
+ 000000000000000000000000000000000000000000000000000000000000001E // uint256
+ "
+ ))
+ .unwrap();
+ assert_eq!(call, u32::to_be_bytes(0x1ACF2D55));
+ let data =
+ <AbiReader<'_> as AbiRead<Vec<(address, uint256)>>>::abi_read(&mut decoder).unwrap();
+ assert_eq!(data.len(), 3);
+ assert_eq!(
+ data,
+ vec![
+ (
+ H160(hex!("2D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC")),
+ U256([10, 0, 0, 0])
+ ),
+ (
+ H160(hex!("AB8E3D9134955566483B11E6825C9223B6737B10")),
+ U256([20, 0, 0, 0])
+ ),
+ (
+ H160(hex!("8C582BDF2953046705FC56F189385255EFC1BE18")),
+ U256([30, 0, 0, 0])
+ ),
+ ]
+ );
+ }
}
pallets/fungible/CHANGELOG.mddiffbeforeafterboth--- a/pallets/fungible/CHANGELOG.md
+++ b/pallets/fungible/CHANGELOG.md
@@ -2,6 +2,13 @@
All notable changes to this project will be documented in this file.
+
+## [0.1.5] - 2022-08-29
+
+### Added
+
+ - Implementation of `mint` and `mint_bulk` methods for ERC20 API.
+
## [v0.1.4] - 2022-08-24
### Change
pallets/fungible/Cargo.tomldiffbeforeafterboth--- a/pallets/fungible/Cargo.toml
+++ b/pallets/fungible/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "pallet-fungible"
-version = "0.1.4"
+version = "0.1.5"
license = "GPLv3"
edition = "2021"
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -129,8 +129,32 @@
}
}
+#[solidity_interface(name = ERC20Mintable)]
+impl<T: Config> FungibleHandle<T> {
+ /// Mint tokens for `to` account.
+ /// @param to account that will receive minted tokens
+ /// @param amount amount of tokens to mint
+ #[weight(<SelfWeightOf<T>>::create_item())]
+ fn mint(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = T::CrossAccountId::from_eth(to);
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+ let budget = self
+ .recorder
+ .weight_calls_budget(<StructureWeight<T>>::find_parent());
+ <Pallet<T>>::create_item(&self, &caller, (to, amount), &budget)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
+}
+
#[solidity_interface(name = ERC20UniqueExtensions)]
impl<T: Config> FungibleHandle<T> {
+ /// Burn tokens from account
+ /// @dev Function that burns an `amount` of the tokens 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(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
@@ -144,12 +168,36 @@
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
+
+ /// Mint tokens for multiple accounts.
+ /// @param amounts array of pairs of account address and amount
+ #[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
+ fn mint_bulk(&mut self, caller: caller, amounts: Vec<(address, uint256)>) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let budget = self
+ .recorder
+ .weight_calls_budget(<StructureWeight<T>>::find_parent());
+ let amounts = amounts
+ .into_iter()
+ .map(|(to, amount)| {
+ Ok((
+ T::CrossAccountId::from_eth(to),
+ amount.try_into().map_err(|_| "amount overflow")?,
+ ))
+ })
+ .collect::<Result<_>>()?;
+
+ <Pallet<T>>::create_multiple_items(&self, &caller, amounts, &budget)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(true)
+ }
}
#[solidity_interface(
name = UniqueFungible,
is(
ERC20,
+ ERC20Mintable,
ERC20UniqueExtensions,
Collection(common_mut, CollectionHandle<T>),
)
pallets/fungible/src/stubs/UniqueFungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/fungible/src/stubs/UniqueFungible.soldiffbeforeafterboth--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -350,19 +350,51 @@
}
}
+/// @dev the ERC-165 identifier for this interface is 0x63034ac5
+contract ERC20UniqueExtensions is Dummy, ERC165 {
+ /// Burn tokens from account
+ /// @dev Function that burns an `amount` of the tokens 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: 0x79cc6790,
+ /// or in textual repr: burnFrom(address,uint256)
+ function burnFrom(address from, uint256 amount) public returns (bool) {
+ require(false, stub_error);
+ from;
+ amount;
+ dummy = 0;
+ return false;
+ }
+
+ /// Mint tokens for multiple accounts.
+ /// @param amounts array of pairs of account address and amount
+ /// @dev EVM selector for this function is: 0x1acf2d55,
+ /// or in textual repr: mintBulk((address,uint256)[])
+ function mintBulk(Tuple6[] memory amounts) public returns (bool) {
+ require(false, stub_error);
+ amounts;
+ dummy = 0;
+ return false;
+ }
+}
+
/// @dev anonymous struct
struct Tuple6 {
address field_0;
uint256 field_1;
}
-/// @dev the ERC-165 identifier for this interface is 0x79cc6790
-contract ERC20UniqueExtensions is Dummy, ERC165 {
- /// @dev EVM selector for this function is: 0x79cc6790,
- /// or in textual repr: burnFrom(address,uint256)
- function burnFrom(address from, uint256 amount) public returns (bool) {
+/// @dev the ERC-165 identifier for this interface is 0x40c10f19
+contract ERC20Mintable is Dummy, ERC165 {
+ /// Mint tokens for `to` account.
+ /// @param to account that will receive minted tokens
+ /// @param amount amount of tokens to mint
+ /// @dev EVM selector for this function is: 0x40c10f19,
+ /// or in textual repr: mint(address,uint256)
+ function mint(address to, uint256 amount) public returns (bool) {
require(false, stub_error);
- from;
+ to;
amount;
dummy = 0;
return false;
@@ -476,6 +508,7 @@
Dummy,
ERC165,
ERC20,
+ ERC20Mintable,
ERC20UniqueExtensions,
Collection
{}
tests/src/eth/api/UniqueFungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -225,17 +225,38 @@
function setOwnerSubstrate(uint256 newOwner) external;
}
+/// @dev the ERC-165 identifier for this interface is 0x63034ac5
+interface ERC20UniqueExtensions is Dummy, ERC165 {
+ /// Burn tokens from account
+ /// @dev Function that burns an `amount` of the tokens 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: 0x79cc6790,
+ /// or in textual repr: burnFrom(address,uint256)
+ function burnFrom(address from, uint256 amount) external returns (bool);
+
+ /// Mint tokens for multiple accounts.
+ /// @param amounts array of pairs of account address and amount
+ /// @dev EVM selector for this function is: 0x1acf2d55,
+ /// or in textual repr: mintBulk((address,uint256)[])
+ function mintBulk(Tuple6[] memory amounts) external returns (bool);
+}
+
/// @dev anonymous struct
struct Tuple6 {
address field_0;
uint256 field_1;
}
-/// @dev the ERC-165 identifier for this interface is 0x79cc6790
-interface ERC20UniqueExtensions is Dummy, ERC165 {
- /// @dev EVM selector for this function is: 0x79cc6790,
- /// or in textual repr: burnFrom(address,uint256)
- function burnFrom(address from, uint256 amount) external returns (bool);
+/// @dev the ERC-165 identifier for this interface is 0x40c10f19
+interface ERC20Mintable is Dummy, ERC165 {
+ /// Mint tokens for `to` account.
+ /// @param to account that will receive minted tokens
+ /// @param amount amount of tokens to mint
+ /// @dev EVM selector for this function is: 0x40c10f19,
+ /// or in textual repr: mint(address,uint256)
+ function mint(address to, uint256 amount) external returns (bool);
}
/// @dev inlined interface
@@ -298,6 +319,7 @@
Dummy,
ERC165,
ERC20,
+ ERC20Mintable,
ERC20UniqueExtensions,
Collection
{}
tests/src/eth/fungible.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 {approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE} from '../util/helpers';18import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth} from './util/helpers';19import fungibleAbi from './fungibleAbi.json';20import {expect} from 'chai';2122describe('Fungible: Information getting', () => {23 itWeb3('totalSupply', async ({api, web3, privateKeyWrapper}) => {24 const collection = await createCollectionExpectSuccess({25 name: 'token name',26 mode: {type: 'Fungible', decimalPoints: 0},27 });28 const alice = privateKeyWrapper('//Alice');2930 const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);3132 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Substrate: alice.address});3334 const address = collectionIdToAddress(collection);35 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});36 const totalSupply = await contract.methods.totalSupply().call();3738 expect(totalSupply).to.equal('200');39 });4041 itWeb3('balanceOf', async ({api, web3, privateKeyWrapper}) => {42 const collection = await createCollectionExpectSuccess({43 name: 'token name',44 mode: {type: 'Fungible', decimalPoints: 0},45 });46 const alice = privateKeyWrapper('//Alice');4748 const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);4950 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: caller});5152 const address = collectionIdToAddress(collection);53 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});54 const balance = await contract.methods.balanceOf(caller).call();5556 expect(balance).to.equal('200');57 });58});5960describe('Fungible: Plain calls', () => {61 itWeb3('Can perform approve()', async ({web3, api, privateKeyWrapper}) => {62 const collection = await createCollectionExpectSuccess({63 name: 'token name',64 mode: {type: 'Fungible', decimalPoints: 0},65 });66 const alice = privateKeyWrapper('//Alice');6768 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);6970 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});7172 const spender = createEthAccount(web3);7374 const address = collectionIdToAddress(collection);75 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});7677 {78 const result = await contract.methods.approve(spender, 100).send({from: owner});79 const events = normalizeEvents(result.events);8081 expect(events).to.be.deep.equal([82 {83 address,84 event: 'Approval',85 args: {86 owner,87 spender,88 value: '100',89 },90 },91 ]);92 }9394 {95 const allowance = await contract.methods.allowance(owner, spender).call();96 expect(+allowance).to.equal(100);97 }98 });99100 itWeb3('Can perform transferFrom()', async ({web3, api, privateKeyWrapper}) => {101 const collection = await createCollectionExpectSuccess({102 name: 'token name',103 mode: {type: 'Fungible', decimalPoints: 0},104 });105 const alice = privateKeyWrapper('//Alice');106107 const owner = createEthAccount(web3);108 await transferBalanceToEth(api, alice, owner);109110 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});111112 const spender = createEthAccount(web3);113 await transferBalanceToEth(api, alice, spender);114115 const receiver = createEthAccount(web3);116117 const address = collectionIdToAddress(collection);118 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});119120 await contract.methods.approve(spender, 100).send();121122 {123 const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});124 const events = normalizeEvents(result.events);125 expect(events).to.be.deep.equal([126 {127 address,128 event: 'Transfer',129 args: {130 from: owner,131 to: receiver,132 value: '49',133 },134 },135 {136 address,137 event: 'Approval',138 args: {139 owner,140 spender,141 value: '51',142 },143 },144 ]);145 }146147 {148 const balance = await contract.methods.balanceOf(receiver).call();149 expect(+balance).to.equal(49);150 }151152 {153 const balance = await contract.methods.balanceOf(owner).call();154 expect(+balance).to.equal(151);155 }156 });157158 itWeb3('Can perform transfer()', async ({web3, api, privateKeyWrapper}) => {159 const collection = await createCollectionExpectSuccess({160 name: 'token name',161 mode: {type: 'Fungible', decimalPoints: 0},162 });163 const alice = privateKeyWrapper('//Alice');164165 const owner = createEthAccount(web3);166 await transferBalanceToEth(api, alice, owner);167168 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});169170 const receiver = createEthAccount(web3);171 await transferBalanceToEth(api, alice, receiver);172173 const address = collectionIdToAddress(collection);174 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});175176 {177 const result = await contract.methods.transfer(receiver, 50).send({from: owner});178 const events = normalizeEvents(result.events);179 expect(events).to.be.deep.equal([180 {181 address,182 event: 'Transfer',183 args: {184 from: owner,185 to: receiver,186 value: '50',187 },188 },189 ]);190 }191192 {193 const balance = await contract.methods.balanceOf(owner).call();194 expect(+balance).to.equal(150);195 }196197 {198 const balance = await contract.methods.balanceOf(receiver).call();199 expect(+balance).to.equal(50);200 }201 });202});203204describe('Fungible: Fees', () => {205 itWeb3('approve() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {206 const collection = await createCollectionExpectSuccess({207 mode: {type: 'Fungible', decimalPoints: 0},208 });209 const alice = privateKeyWrapper('//Alice');210211 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);212 const spender = createEthAccount(web3);213214 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});215216 const address = collectionIdToAddress(collection);217 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});218219 const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({from: owner}));220 expect(cost < BigInt(0.2 * Number(UNIQUE)));221 });222223 itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {224 const collection = await createCollectionExpectSuccess({225 mode: {type: 'Fungible', decimalPoints: 0},226 });227 const alice = privateKeyWrapper('//Alice');228229 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);230 const spender = await createEthAccountWithBalance(api, web3, privateKeyWrapper);231232 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});233234 const address = collectionIdToAddress(collection);235 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});236237 await contract.methods.approve(spender, 100).send({from: owner});238239 const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));240 expect(cost < BigInt(0.2 * Number(UNIQUE)));241 });242243 itWeb3('transfer() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {244 const collection = await createCollectionExpectSuccess({245 mode: {type: 'Fungible', decimalPoints: 0},246 });247 const alice = privateKeyWrapper('//Alice');248249 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);250 const receiver = createEthAccount(web3);251252 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});253254 const address = collectionIdToAddress(collection);255 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});256257 const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));258 expect(cost < BigInt(0.2 * Number(UNIQUE)));259 });260});261262describe('Fungible: Substrate calls', () => {263 itWeb3('Events emitted for approve()', async ({web3, privateKeyWrapper}) => {264 const collection = await createCollectionExpectSuccess({265 mode: {type: 'Fungible', decimalPoints: 0},266 });267 const alice = privateKeyWrapper('//Alice');268269 const receiver = createEthAccount(web3);270271 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});272273 const address = collectionIdToAddress(collection);274 const contract = new web3.eth.Contract(fungibleAbi as any, address);275276 const events = await recordEvents(contract, async () => {277 await approveExpectSuccess(collection, 0, alice, {Ethereum: receiver}, 100);278 });279280 expect(events).to.be.deep.equal([281 {282 address,283 event: 'Approval',284 args: {285 owner: subToEth(alice.address),286 spender: receiver,287 value: '100',288 },289 },290 ]);291 });292293 itWeb3('Events emitted for transferFrom()', async ({web3, privateKeyWrapper}) => {294 const collection = await createCollectionExpectSuccess({295 mode: {type: 'Fungible', decimalPoints: 0},296 });297 const alice = privateKeyWrapper('//Alice');298 const bob = privateKeyWrapper('//Bob');299300 const receiver = createEthAccount(web3);301302 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});303 await approveExpectSuccess(collection, 0, alice, bob.address, 100);304305 const address = collectionIdToAddress(collection);306 const contract = new web3.eth.Contract(fungibleAbi as any, address);307308 const events = await recordEvents(contract, async () => {309 await transferFromExpectSuccess(collection, 0, bob, alice, {Ethereum: receiver}, 51, 'Fungible');310 });311312 expect(events).to.be.deep.equal([313 {314 address,315 event: 'Transfer',316 args: {317 from: subToEth(alice.address),318 to: receiver,319 value: '51',320 },321 },322 {323 address,324 event: 'Approval',325 args: {326 owner: subToEth(alice.address),327 spender: subToEth(bob.address),328 value: '49',329 },330 },331 ]);332 });333334 itWeb3('Events emitted for transfer()', async ({web3, privateKeyWrapper}) => {335 const collection = await createCollectionExpectSuccess({336 mode: {type: 'Fungible', decimalPoints: 0},337 });338 const alice = privateKeyWrapper('//Alice');339340 const receiver = createEthAccount(web3);341342 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});343344 const address = collectionIdToAddress(collection);345 const contract = new web3.eth.Contract(fungibleAbi as any, address);346347 const events = await recordEvents(contract, async () => {348 await transferExpectSuccess(collection, 0, alice, {Ethereum:receiver}, 51, 'Fungible');349 });350351 expect(events).to.be.deep.equal([352 {353 address,354 event: 'Transfer',355 args: {356 from: subToEth(alice.address),357 to: receiver,358 value: '51',359 },360 },361 ]);362 });363});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 {approveExpectSuccess, createCollection, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE} from '../util/helpers';18import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth} from './util/helpers';19import fungibleAbi from './fungibleAbi.json';20import {expect} from 'chai';21import {submitTransactionAsync} from '../substrate/substrate-api';2223describe('Fungible: Information getting', () => {24 itWeb3('totalSupply', async ({api, web3, privateKeyWrapper}) => {25 const collection = await createCollectionExpectSuccess({26 name: 'token name',27 mode: {type: 'Fungible', decimalPoints: 0},28 });29 const alice = privateKeyWrapper('//Alice');3031 const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);3233 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Substrate: alice.address});3435 const address = collectionIdToAddress(collection);36 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});37 const totalSupply = await contract.methods.totalSupply().call();3839 expect(totalSupply).to.equal('200');40 });4142 itWeb3('balanceOf', async ({api, web3, privateKeyWrapper}) => {43 const collection = await createCollectionExpectSuccess({44 name: 'token name',45 mode: {type: 'Fungible', decimalPoints: 0},46 });47 const alice = privateKeyWrapper('//Alice');4849 const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);5051 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: caller});5253 const address = collectionIdToAddress(collection);54 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});55 const balance = await contract.methods.balanceOf(caller).call();5657 expect(balance).to.equal('200');58 });59});6061describe('Fungible: Plain calls', () => {62 itWeb3('Can perform mint()', async ({web3, api, privateKeyWrapper}) => {63 const alice = privateKeyWrapper('//Alice');64 const collection = await createCollection(api, alice, {65 name: 'token name',66 mode: {type: 'Fungible', decimalPoints: 0},67 });6869 const receiver = createEthAccount(web3);7071 const collectionIdAddress = collectionIdToAddress(collection.collectionId);72 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);73 const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});74 await submitTransactionAsync(alice, changeAdminTx);7576 const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});77 const result = await collectionContract.methods.mint(receiver, 100).send();78 const events = normalizeEvents(result.events);79 80 expect(events).to.be.deep.equal([81 {82 address: collectionIdAddress,83 event: 'Transfer',84 args: {85 from: '0x0000000000000000000000000000000000000000',86 to: receiver,87 value: '100',88 },89 },90 ]);91 });9293 itWeb3('Can perform mintBulk()', async ({web3, api, privateKeyWrapper}) => {94 const alice = privateKeyWrapper('//Alice');95 const collection = await createCollection(api, alice, {96 name: 'token name',97 mode: {type: 'Fungible', decimalPoints: 0},98 });99100 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);101 const receiver1 = createEthAccount(web3);102 const receiver2 = createEthAccount(web3);103 const receiver3 = createEthAccount(web3);104105 const collectionIdAddress = collectionIdToAddress(collection.collectionId);106 const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});107 await submitTransactionAsync(alice, changeAdminTx);108109 const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});110 const result = await collectionContract.methods.mintBulk([111 [receiver1, 10],112 [receiver2, 20],113 [receiver3, 30],114 ]).send();115 const events = normalizeEvents(result.events);116117 expect(events).to.be.deep.contain({118 address:collectionIdAddress,119 event: 'Transfer',120 args: {121 from: '0x0000000000000000000000000000000000000000',122 to: receiver1,123 value: '10',124 },125 });126 127 expect(events).to.be.deep.contain({128 address:collectionIdAddress,129 event: 'Transfer',130 args: {131 from: '0x0000000000000000000000000000000000000000',132 to: receiver2,133 value: '20',134 },135 });136 137 expect(events).to.be.deep.contain({138 address:collectionIdAddress,139 event: 'Transfer',140 args: {141 from: '0x0000000000000000000000000000000000000000',142 to: receiver3,143 value: '30',144 },145 });146 });147148 itWeb3('Can perform burn()', async ({web3, api, privateKeyWrapper}) => {149 const alice = privateKeyWrapper('//Alice');150 const collection = await createCollection(api, alice, {151 name: 'token name',152 mode: {type: 'Fungible', decimalPoints: 0},153 });154155 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);156 const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});157 await submitTransactionAsync(alice, changeAdminTx);158 const receiver = await createEthAccountWithBalance(api, web3, privateKeyWrapper);159160 const collectionIdAddress = collectionIdToAddress(collection.collectionId);161 const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});162 await collectionContract.methods.mint(receiver, 100).send();163164 const result = await collectionContract.methods.burnFrom(receiver, 49).send({from: receiver});165 166 const events = normalizeEvents(result.events);167168 expect(events).to.be.deep.equal([169 {170 address: collectionIdAddress,171 event: 'Transfer',172 args: {173 from: receiver,174 to: '0x0000000000000000000000000000000000000000',175 value: '49',176 },177 },178 ]);179180 const balance = await collectionContract.methods.balanceOf(receiver).call();181 expect(balance).to.equal('51');182 });183184 itWeb3('Can perform approve()', async ({web3, api, privateKeyWrapper}) => {185 const collection = await createCollectionExpectSuccess({186 name: 'token name',187 mode: {type: 'Fungible', decimalPoints: 0},188 });189 const alice = privateKeyWrapper('//Alice');190191 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);192193 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});194195 const spender = createEthAccount(web3);196197 const address = collectionIdToAddress(collection);198 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});199200 {201 const result = await contract.methods.approve(spender, 100).send({from: owner});202 const events = normalizeEvents(result.events);203204 expect(events).to.be.deep.equal([205 {206 address,207 event: 'Approval',208 args: {209 owner,210 spender,211 value: '100',212 },213 },214 ]);215 }216217 {218 const allowance = await contract.methods.allowance(owner, spender).call();219 expect(+allowance).to.equal(100);220 }221 });222223 itWeb3('Can perform transferFrom()', async ({web3, api, privateKeyWrapper}) => {224 const collection = await createCollectionExpectSuccess({225 name: 'token name',226 mode: {type: 'Fungible', decimalPoints: 0},227 });228 const alice = privateKeyWrapper('//Alice');229230 const owner = createEthAccount(web3);231 await transferBalanceToEth(api, alice, owner);232233 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});234235 const spender = createEthAccount(web3);236 await transferBalanceToEth(api, alice, spender);237238 const receiver = createEthAccount(web3);239240 const address = collectionIdToAddress(collection);241 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});242243 await contract.methods.approve(spender, 100).send();244245 {246 const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});247 const events = normalizeEvents(result.events);248 expect(events).to.be.deep.equal([249 {250 address,251 event: 'Transfer',252 args: {253 from: owner,254 to: receiver,255 value: '49',256 },257 },258 {259 address,260 event: 'Approval',261 args: {262 owner,263 spender,264 value: '51',265 },266 },267 ]);268 }269270 {271 const balance = await contract.methods.balanceOf(receiver).call();272 expect(+balance).to.equal(49);273 }274275 {276 const balance = await contract.methods.balanceOf(owner).call();277 expect(+balance).to.equal(151);278 }279 });280281 itWeb3('Can perform transfer()', async ({web3, api, privateKeyWrapper}) => {282 const collection = await createCollectionExpectSuccess({283 name: 'token name',284 mode: {type: 'Fungible', decimalPoints: 0},285 });286 const alice = privateKeyWrapper('//Alice');287288 const owner = createEthAccount(web3);289 await transferBalanceToEth(api, alice, owner);290291 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});292293 const receiver = createEthAccount(web3);294 await transferBalanceToEth(api, alice, receiver);295296 const address = collectionIdToAddress(collection);297 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});298299 {300 const result = await contract.methods.transfer(receiver, 50).send({from: owner});301 const events = normalizeEvents(result.events);302 expect(events).to.be.deep.equal([303 {304 address,305 event: 'Transfer',306 args: {307 from: owner,308 to: receiver,309 value: '50',310 },311 },312 ]);313 }314315 {316 const balance = await contract.methods.balanceOf(owner).call();317 expect(+balance).to.equal(150);318 }319320 {321 const balance = await contract.methods.balanceOf(receiver).call();322 expect(+balance).to.equal(50);323 }324 });325});326327describe('Fungible: Fees', () => {328 itWeb3('approve() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {329 const collection = await createCollectionExpectSuccess({330 mode: {type: 'Fungible', decimalPoints: 0},331 });332 const alice = privateKeyWrapper('//Alice');333334 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);335 const spender = createEthAccount(web3);336337 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});338339 const address = collectionIdToAddress(collection);340 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});341342 const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({from: owner}));343 expect(cost < BigInt(0.2 * Number(UNIQUE)));344 });345346 itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {347 const collection = await createCollectionExpectSuccess({348 mode: {type: 'Fungible', decimalPoints: 0},349 });350 const alice = privateKeyWrapper('//Alice');351352 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);353 const spender = await createEthAccountWithBalance(api, web3, privateKeyWrapper);354355 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});356357 const address = collectionIdToAddress(collection);358 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});359360 await contract.methods.approve(spender, 100).send({from: owner});361362 const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));363 expect(cost < BigInt(0.2 * Number(UNIQUE)));364 });365366 itWeb3('transfer() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {367 const collection = await createCollectionExpectSuccess({368 mode: {type: 'Fungible', decimalPoints: 0},369 });370 const alice = privateKeyWrapper('//Alice');371372 const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);373 const receiver = createEthAccount(web3);374375 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});376377 const address = collectionIdToAddress(collection);378 const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});379380 const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));381 expect(cost < BigInt(0.2 * Number(UNIQUE)));382 });383});384385describe('Fungible: Substrate calls', () => {386 itWeb3('Events emitted for approve()', async ({web3, privateKeyWrapper}) => {387 const collection = await createCollectionExpectSuccess({388 mode: {type: 'Fungible', decimalPoints: 0},389 });390 const alice = privateKeyWrapper('//Alice');391392 const receiver = createEthAccount(web3);393394 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});395396 const address = collectionIdToAddress(collection);397 const contract = new web3.eth.Contract(fungibleAbi as any, address);398399 const events = await recordEvents(contract, async () => {400 await approveExpectSuccess(collection, 0, alice, {Ethereum: receiver}, 100);401 });402403 expect(events).to.be.deep.equal([404 {405 address,406 event: 'Approval',407 args: {408 owner: subToEth(alice.address),409 spender: receiver,410 value: '100',411 },412 },413 ]);414 });415416 itWeb3('Events emitted for transferFrom()', async ({web3, privateKeyWrapper}) => {417 const collection = await createCollectionExpectSuccess({418 mode: {type: 'Fungible', decimalPoints: 0},419 });420 const alice = privateKeyWrapper('//Alice');421 const bob = privateKeyWrapper('//Bob');422423 const receiver = createEthAccount(web3);424425 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});426 await approveExpectSuccess(collection, 0, alice, bob.address, 100);427428 const address = collectionIdToAddress(collection);429 const contract = new web3.eth.Contract(fungibleAbi as any, address);430431 const events = await recordEvents(contract, async () => {432 await transferFromExpectSuccess(collection, 0, bob, alice, {Ethereum: receiver}, 51, 'Fungible');433 });434435 expect(events).to.be.deep.equal([436 {437 address,438 event: 'Transfer',439 args: {440 from: subToEth(alice.address),441 to: receiver,442 value: '51',443 },444 },445 {446 address,447 event: 'Approval',448 args: {449 owner: subToEth(alice.address),450 spender: subToEth(bob.address),451 value: '49',452 },453 },454 ]);455 });456457 itWeb3('Events emitted for transfer()', async ({web3, privateKeyWrapper}) => {458 const collection = await createCollectionExpectSuccess({459 mode: {type: 'Fungible', decimalPoints: 0},460 });461 const alice = privateKeyWrapper('//Alice');462463 const receiver = createEthAccount(web3);464465 await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});466467 const address = collectionIdToAddress(collection);468 const contract = new web3.eth.Contract(fungibleAbi as any, address);469470 const events = await recordEvents(contract, async () => {471 await transferExpectSuccess(collection, 0, alice, {Ethereum:receiver}, 51, 'Fungible');472 });473474 expect(events).to.be.deep.equal([475 {476 address,477 event: 'Transfer',478 args: {479 from: subToEth(alice.address),480 to: receiver,481 value: '51',482 },483 },484 ]);485 });486});tests/src/eth/fungibleAbi.jsondiffbeforeafterboth--- a/tests/src/eth/fungibleAbi.json
+++ b/tests/src/eth/fungibleAbi.json
@@ -193,6 +193,33 @@
"type": "function"
},
{
+ "inputs": [
+ { "internalType": "address", "name": "to", "type": "address" },
+ { "internalType": "uint256", "name": "amount", "type": "uint256" }
+ ],
+ "name": "mint",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ { "internalType": "address", "name": "field_0", "type": "address" },
+ { "internalType": "uint256", "name": "field_1", "type": "uint256" }
+ ],
+ "internalType": "struct Tuple6[]",
+ "name": "amounts",
+ "type": "tuple[]"
+ }
+ ],
+ "name": "mintBulk",
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
"inputs": [],
"name": "name",
"outputs": [{ "internalType": "string", "name": "", "type": "string" }],