`1913bf6018fe`

4 files changed

modifiedtests/package.jsondiff before after both

47    "testEthNesting": "yarn _test './**/eth/nesting/**/*.*test.ts'",47    "testEthNesting": "yarn _test './**/eth/nesting/**/*.*test.ts'",
48    "testEthFractionalizer": "yarn _test './**/eth/fractionalizer/**/*.*test.ts'",48    "testEthFractionalizer": "yarn _test './**/eth/fractionalizer/**/*.*test.ts'",
49    "testEthMarketplace": "yarn _test './**/eth/marketplace/**/*.*test.ts'",49    "testEthMarketplace": "yarn _test './**/eth/marketplace/**/*.*test.ts'",
50    "testEthMarket": "yarn _test './**/eth/marketplace-v2/**/*.*test.ts'",
50    "testSub": "yarn _test './**/sub/**/*.*test.ts'",51    "testSub": "yarn _test './**/sub/**/*.*test.ts'",
51    "testSubNesting": "yarn _test './**/sub/nesting/**/*.*test.ts'",52    "testSubNesting": "yarn _test './**/sub/nesting/**/*.*test.ts'",
52    "testEvent": "yarn _test ./src/check-event/*.*test.ts",53    "testEvent": "yarn _test ./src/check-event/*.*test.ts",

modifiedtests/src/eth/marketplace-v2/Market.soldiff before after both

1// SPDX-License-Identifier: UNLICENSED1// SPDX-License-Identifier: UNLICENSED
2pragma solidity 0.8.17;2pragma solidity 0.8.17;
33
4import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
4import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";5import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
5import "@openzeppelin/contracts/token/ERC721/IERC721.sol";6import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
7import "@openzeppelin/contracts/access/Ownable.sol";
6import { UniqueNFT, CrossAddress } from "@unique-nft/solidity-interfaces/contracts/UniqueNFT.sol";8import { UniqueNFT, CrossAddress } from "@unique-nft/solidity-interfaces/contracts/UniqueNFT.sol";
9import { UniqueFungible, CrossAddress as CrossAddressF } from "@unique-nft/solidity-interfaces/contracts/UniqueFungible.sol";
7import "@unique-nft/solidity-interfaces/contracts/CollectionHelpers.sol";10import "@unique-nft/solidity-interfaces/contracts/CollectionHelpers.sol";
8import "./royalty/UniqueRoyaltyHelper.sol";11import "./royalty/UniqueRoyaltyHelper.sol";
912
10contract Market {13contract Market is Ownable, ReentrancyGuard {
11    using ERC165Checker for address;14    using ERC165Checker for address;
1215
13    struct Order {16    struct Order {
20    }23    }
2124
22    uint32 public constant version = 0;25    uint32 public constant version = 0;
26    uint32 public constant buildVersion = 3;
23    bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;27    bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
24    bytes4 private constant InterfaceId_ERC165 = 0x5755c3f2;28    bytes4 private constant InterfaceId_ERC165 = 0x5755c3f2;
25    CollectionHelpers private constant collectionHelpers =29    CollectionHelpers private constant collectionHelpers =
29    uint32 private idCount = 1;33    uint32 private idCount = 1;
30    uint32 public marketFee;34    uint32 public marketFee;
31    uint64 public ctime;35    uint64 public ctime;
32    address selfAddress;
33    address public ownerAddress;36    address public ownerAddress;
34    mapping(address => bool) public admins;37    mapping(address => bool) public admins;
3538
55    error OrderNotFound();58    error OrderNotFound();
56    error TooManyAmountRequested();59    error TooManyAmountRequested();
57    error NotEnoughMoneyError();60    error NotEnoughMoneyError();
61    error InvalidRoyaltiesError(uint256 totalRoyalty);
58    error FailTransferToken(string reason);62    error FailTransferToken(string reason);
59
60    modifier onlyOwner() {
61      require(msg.sender == ownerAddress, "Only owner can");
62      _;
63    }
6463
65    modifier onlyAdmin() {64    modifier onlyAdmin() {
66      require(msg.sender == ownerAddress || admins[msg.sender], "Only admin can");65      require(msg.sender == this.owner() || admins[msg.sender], "Only admin can");
67      _;66      _;
68    }67    }
6968
83        marketFee = fee;82        marketFee = fee;
84        ctime = timestamp;83        ctime = timestamp;
8584
86        if (marketFee == 0 || marketFee >= 100) {85        if (marketFee >= 100) {
87            revert InvalidMarketFee();86            revert InvalidMarketFee();
88        }87        }
89
90        ownerAddress = msg.sender;
91        selfAddress = address(this);
92    }88    }
89
90    /**
91     * Fallback that allows this contract to receive native token.
92     * We need this for self-sponsoring
93     */
94    fallback() external payable {}
95
96    /**
97     * Receive also allows this contract to receive native token.
98     * We need this for self-sponsoring
99     */
100    receive() external payable {}
93101
94    function getErc721(uint32 collectionId) private view returns (IERC721) {102    function getErc721(uint32 collectionId) private view returns (IERC721) {
95        address collectionAddress = collectionHelpers.collectionAddress(103        address collectionAddress = collectionHelpers.collectionAddress(
112        return IERC721(collectionAddress);120        return IERC721(collectionAddress);
113    }121    }
114122
115    // ################################################################123    /**
116    // Set new contract owner                                         #124     * Add new admin. Only owner or an existing admin can add admins.
117    // ################################################################125     *
118126     * @param admin: Address of a new admin to add
119    function setOwner() public onlyOwner {127     */
120        ownerAddress = msg.sender;
121    }
122
123    // ################################################################
124    // Add new admin                                                  #
125    // ################################################################
126
127    function addAdmin(address admin) public onlyAdmin {128    function addAdmin(address admin) public onlyAdmin {
128      admins[admin] = true;129      admins[admin] = true;
129    }130    }
130131
131    // ################################################################132    /**
132    // Remove admin                                                  #133     * Remove an admin. Only owner or an existing admin can remove admins.
133    // ################################################################134     *
134135     * @param admin: Address of a new admin to add
136     */
135    function removeAdmin(address admin) public onlyAdmin {137    function removeAdmin(address admin) public onlyAdmin {
136      delete admins[admin];138      delete admins[admin];
137    }139    }
138140
139    // ################################################################141    /**
140    // Place a token for sale                                         #142     * Place an NFT or RFT token for sale. It must be pre-approved for transfers by this contract address.
141    // ################################################################143     *
142144     * @param collectionId: ID of the token collection
145     * @param tokenId: ID of the token
146     * @param price: Price (with proper network currency decimals)
147     * @param amount: Number of token fractions to list (must always be 1 for NFT)
148     * @param seller: The seller cross-address (the beneficiary account to receive payment, may be different from transaction sender)
149     */
143    function put(150    function put(
144        uint32 collectionId,151        uint32 collectionId,
145        uint32 tokenId,152        uint32 tokenId,
164          revert SellerIsNotOwner();171          revert SellerIsNotOwner();
165        }172        }
166173
167        if (erc721.getApproved(tokenId) != selfAddress) {174        if (erc721.getApproved(tokenId) != address(this)) {
168          revert TokenIsNotApproved();175          revert TokenIsNotApproved();
169        }176        }
170177
183        emit TokenIsUpForSale(version, order);190        emit TokenIsUpForSale(version, order);
184    }191    }
185192
186    // ################################################################193    /**
187    // Get order                                                      #194     * Get information about the listed token order
188    // ################################################################195     *
189196     * @param collectionId: ID of the token collection
197     * @param tokenId: ID of the token
198     * @return The order information
199     */
190    function getOrder(200    function getOrder(
191        uint32 collectionId,201        uint32 collectionId,
192        uint32 tokenId202        uint32 tokenId
193    ) external view returns (Order memory) {203    ) external view returns (Order memory) {
194        return orders[collectionId][tokenId];204        return orders[collectionId][tokenId];
195    }205    }
196206
197    // ################################################################207    /**
198    // Revoke the token from the sale                                 #208     * Revoke the token from the sale. Only the original lister can use this method.
199    // ################################################################209     *
200210     * @param collectionId: ID of the token collection
211     * @param tokenId: ID of the token
212     * @param amount: Number of token fractions to de-list (must always be 1 for NFT)
213     */
201    function revoke(214    function revoke(
202        uint32 collectionId,215        uint32 collectionId,
203        uint32 tokenId,216        uint32 tokenId,
239        emit TokenRevoke(version, order, amount);252        emit TokenRevoke(version, order, amount);
240    }253    }
241254
242    // ################################################################255    /**
243    // Check approved                                                 #256     * Test if the token is still approved to be transferred by this contract and delete the order if not.
244    // ################################################################257     *
245258     * @param collectionId: ID of the token collection
259     * @param tokenId: ID of the token
260     */
246    function checkApproved(uint32 collectionId, uint32 tokenId) public onlyAdmin {261    function checkApproved(uint32 collectionId, uint32 tokenId) public onlyAdmin {
247        Order memory order = orders[collectionId][tokenId];262        Order memory order = orders[collectionId][tokenId];
248        if (order.price == 0) {263        if (order.price == 0) {
251266
252        IERC721 erc721 = getErc721(collectionId);267        IERC721 erc721 = getErc721(collectionId);
253268
254        if (erc721.getApproved(tokenId) != selfAddress) {269        if (erc721.getApproved(tokenId) != address(this) || erc721.ownerOf(tokenId) != getAddressFromCrossAccount(order.seller)) {
255          uint32 amount = order.amount;270          uint32 amount = order.amount;
256          order.amount = 0;271          order.amount = 0;
257          emit TokenRevoke(version, order, amount);272          emit TokenRevoke(version, order, amount);
262        }277        }
263    }278    }
264279
265    // ################################################################280    function getAddressFromCrossAccount(CrossAddress memory account) private pure returns (address) {
266    // Buy a token                                                    #281        if (account.eth != address(0)) {
267    // ################################################################282            return account.eth;
268283        } else {
284            return address(uint160(account.sub >> 96));
285        }
286    }
287
288    /**
289     * Revoke the token from the sale. Only the contract admin can use this method.
290     *
291     * @param collectionId: ID of the token collection
292     * @param tokenId: ID of the token
293     */
294    function revokeAdmin(uint32 collectionId, uint32 tokenId) public onlyAdmin {
295        Order memory order = orders[collectionId][tokenId];
296        if (order.price == 0) {
297          revert OrderNotFound();
298        }
299
300        uint32 amount = order.amount;
301        order.amount = 0;
302        emit TokenRevoke(version, order, amount);
303
304        delete orders[collectionId][tokenId];
305    }
306
307    /**
308     * Buy a token (partially for an RFT).
309     *
310     * @param collectionId: ID of the token collection
311     * @param tokenId: ID of the token
312     * @param amount: Number of token fractions to buy (must always be 1 for NFT)
313     * @param buyer: Cross-address of the buyer, eth part must be equal to the transaction signer address
314     */
269    function buy(315    function buy(
270        uint32 collectionId,316        uint32 collectionId,
271        uint32 tokenId,317        uint32 tokenId,
272        uint32 amount,318        uint32 amount,
273        CrossAddress memory buyer319        CrossAddress memory buyer
274    ) public payable validCrossAddress(buyer.eth, buyer.sub) {320    ) public payable validCrossAddress(buyer.eth, buyer.sub) nonReentrant {
275        if (msg.value == 0) {321        if (msg.value == 0) {
276          revert InvalidArgument("msg.value must not be zero");322          revert InvalidArgument("msg.value must not be zero");
277        }323        }
296        }342        }
297343
298        IERC721 erc721 = getErc721(order.collectionId);344        IERC721 erc721 = getErc721(order.collectionId);
299        if (erc721.getApproved(tokenId) != selfAddress) {345        if (erc721.getApproved(tokenId) != address(this)) {
300          revert TokenIsNotApproved();346          revert TokenIsNotApproved();
301        }347        }
302348
316          order.tokenId362          order.tokenId
317        );363        );
318364
319        (uint256 totalRoyalty, RoyaltyAmount[] memory royalties) = sendRoyalties(collectionAddress, tokenId, totalValue);365        (uint256 totalRoyalty, RoyaltyAmount[] memory royalties) = sendRoyalties(collectionAddress, tokenId, totalValue - feeValue);
366
367        if (totalRoyalty >= totalValue - feeValue) {
368          revert InvalidRoyaltiesError(totalRoyalty);
369        }
320370
321        sendMoney(order.seller, totalValue - feeValue - totalRoyalty);371        sendMoney(order.seller, totalValue - feeValue - totalRoyalty);
322372
323        if (msg.value > totalValue) {373        if (msg.value > totalValue) {
324            // todo, send money to signer or buyer ?
325            payable(msg.sender).transfer(msg.value - totalValue);374            sendMoney(buyer, msg.value - totalValue);
326        }375        }
327376
328        emit TokenIsPurchased(version, order, amount, buyer, royalties);377        emit TokenIsPurchased(version, order, amount, buyer, royalties);
329    }378    }
330379
331    function sendMoney(CrossAddress memory to, uint256 money) private {380    function sendMoney(CrossAddress memory to, uint256 money) private {
332      address payable eth;381      address collectionAddress = collectionHelpers.collectionAddress(0);
382
333      if (to.eth != address(0)) {383      UniqueFungible fungible = UniqueFungible(collectionAddress);
384
334        eth = payable(to.eth);385      CrossAddressF memory fromF = CrossAddressF(address(this), 0);
335      } else {
336        eth = payable(address(uint160(to.sub >> 96)));386      CrossAddressF memory toF = CrossAddressF(to.eth, to.sub);
337      }387
338      eth.transfer(money);388      fungible.transferFromCross(fromF, toF, money);
339    }389    }
340390
341    function sendRoyalties(address collection, uint tokenId, uint sellPrice) private returns (uint256, RoyaltyAmount[] memory) {391    function sendRoyalties(address collection, uint tokenId, uint sellPrice) private returns (uint256, RoyaltyAmount[] memory) {
355    }405    }
356406
357    function withdraw(address transferTo) public onlyOwner {407    function withdraw(address transferTo) public onlyOwner {
358        uint256 balance = selfAddress.balance;408        uint256 balance = address(this).balance;
359409
360        if (balance > 0) {410        if (balance > 0) {
361            payable(transferTo).transfer(balance);411            payable(transferTo).transfer(balance);

modifiedtests/src/eth/marketplace-v2/marketplace.test.tsdiff before after both

1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {readFile} from 'fs/promises';18import {readFile} from 'fs/promises';
19import {EthUniqueHelper, itEth, usingEthPlaygrounds} from '../util';19import {EthUniqueHelper, SponsoringMode, itEth, usingEthPlaygrounds} from '../util';
20import {makeNames} from '../../util';20import {makeNames} from '../../util';
21import {expect} from 'chai';21import {expect} from 'chai';
22import Web3 from 'web3';22import Web3 from 'web3';
2323
24const {dirname} = makeNames(import.meta.url);24const {dirname} = makeNames(import.meta.url);
25
26const MARKET_FEE = 1;
2527
26describe('Market V2 Contract', () => {28describe('Market V2 Contract', () => {
27  let donor: IKeyringPair;29  let donor: IKeyringPair;
42          solPath: '@unique-nft/solidity-interfaces/contracts/UniqueNFT.sol',44          solPath: '@unique-nft/solidity-interfaces/contracts/UniqueNFT.sol',
43          fsPath: `${dirname}/../api/UniqueNFT.sol`,45          fsPath: `${dirname}/../api/UniqueNFT.sol`,
44        },46        },
47        {
48          solPath: '@unique-nft/solidity-interfaces/contracts/UniqueFungible.sol',
49          fsPath: `${dirname}/../api/UniqueFungible.sol`,
50        },
45        {51        {
46          solPath: '@openzeppelin/contracts/utils/introspection/IERC165.sol',52          solPath: '@openzeppelin/contracts/utils/introspection/IERC165.sol',
47          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol`,53          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol`,
48        },54        },
55        {
56          solPath: '@openzeppelin/contracts/access/Ownable.sol',
57          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/access/Ownable.sol`,
58        },
59        {
60          solPath: '@openzeppelin/contracts/utils/Context.sol',
61          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/utils/Context.sol`,
62        },
63        {
64          solPath: '@openzeppelin/contracts/security/ReentrancyGuard.sol',
65          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol`,
66        },
49        {67        {
50          solPath: '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol',68          solPath: '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol',
51          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/utils/introspection/ERC165Checker.sol`,69          fsPath: `${dirname}/../../../node_modules/@openzeppelin/contracts/utils/introspection/ERC165Checker.sol`,
72        },90        },
73      ],91      ],
74      15000000,92      15000000,
75      [1, 0],93      [MARKET_FEE, 0],
76    );94    );
77  }95  }
7896
90  });108  });
91109
92  itEth('Put + Buy [eth]', async ({helper}) => {110  itEth('Put + Buy [eth]', async ({helper}) => {
111    const ONE_TOKEN = helper.balance.getOneTokenNominal();
112    const PRICE = 2n * ONE_TOKEN;  // 2 UNQ
93    const marketOwner = await helper.eth.createAccountWithBalance(donor, 600n);113    const marketOwner = await helper.eth.createAccountWithBalance(donor, 60000n);
94    const market = await deployMarket(helper, marketOwner);114    const market = await deployMarket(helper, marketOwner);
115    const contractHelpers = helper.ethNativeContract.contractHelpers(marketOwner);
116
117    // Set external sponsoring
118    await contractHelpers.methods.setSponsor(market.options.address, marketOwner).send({from: marketOwner});
119    await contractHelpers.methods.confirmSponsorship(market.options.address).send({from: marketOwner});
120
121    // Configure sponsoring
122    await contractHelpers.methods.setSponsoringMode(market.options.address, SponsoringMode.Generous).send({from: marketOwner});
123    await contractHelpers.methods.setSponsoringRateLimit(market.options.address, 0).send({from: marketOwner});
95124
96    const {collectionId, collectionAddress} = await helper.eth.createNFTCollection(marketOwner, 'Sponsor', 'absolutely anything', 'ROC');125    const {collectionId, collectionAddress} = await helper.eth.createNFTCollection(marketOwner, 'Sponsor', 'absolutely anything', 'ROC');
97    const collection = await helper.ethNativeContract.collection(collectionAddress, 'nft', marketOwner);126    const collection = helper.ethNativeContract.collection(collectionAddress, 'nft', marketOwner, true);
127
128    // Set collection sponsoring
129    await collection.methods.setCollectionSponsor(marketOwner).send({from: marketOwner});
130    await collection.methods.confirmCollectionSponsorship().send({from: marketOwner});
98131
99    const sellerCross = await helper.ethCrossAccount.createAccountWithBalance(donor, 600n);132    const sellerCross = helper.ethCrossAccount.createAccount();
100    const result = await collection.methods.mintCross(sellerCross, []).send();133    const result = await collection.methods.mintCross(sellerCross, []).send();
101    const tokenId = result.events.Transfer.returnValues.tokenId;134    const tokenId = result.events.Transfer.returnValues.tokenId;
102    await collection.methods.approve(market.options.address, tokenId).send({from: sellerCross.eth});135    await collection.methods.approve(market.options.address, tokenId).send({from: sellerCross.eth});
136
137    // Seller has no funds at all, his transactions are sponsored
138    const sellerBalance = await helper.balance.getEthereum(sellerCross.eth);
139    expect(sellerBalance).to.be.eq(0n);
103140
104    const putResult = await market.methods.put(collectionId, tokenId, 1, 1, sellerCross).send({from: sellerCross.eth});141    const putResult = await market.methods.put(collectionId, tokenId, PRICE.toString(), 1, sellerCross).send({
142      from: sellerCross.eth, gasLimit: 1_000_000,
143    });
105    expect(putResult.events.TokenIsUpForSale).is.not.undefined;144    expect(putResult.events.TokenIsUpForSale).is.not.undefined;
145
146    // Seller balance are still 0
147    const sellerBalanceAfter = await helper.balance.getEthereum(sellerCross.eth);
148    expect(sellerBalanceAfter).to.be.eq(0n);
149
106    let ownerCross = await collection.methods.ownerOfCross(tokenId).call();150    let ownerCross = await collection.methods.ownerOfCross(tokenId).call();
107    expect(ownerCross.eth).to.be.eq(sellerCross.eth);151    expect(ownerCross.eth).to.be.eq(sellerCross.eth);
108    expect(ownerCross.sub).to.be.eq(sellerCross.sub);152    expect(ownerCross.sub).to.be.eq(sellerCross.sub);
109153
110    const buyerCross = await helper.ethCrossAccount.createAccountWithBalance(donor, 600n);154    const buyerCross = await helper.ethCrossAccount.createAccountWithBalance(donor, 10n);
155
156    // Buyer has only 10 UNQ
157    const buyerBalance = await helper.balance.getEthereum(buyerCross.eth);
158    expect(buyerBalance).to.be.eq(10n * ONE_TOKEN);
159
111    const buyResult = await market.methods.buy(collectionId, tokenId, 1, buyerCross).send({from: buyerCross.eth, value: 1});160    const buyResult = await market.methods.buy(collectionId, tokenId, 1, buyerCross).send({from: buyerCross.eth, value: PRICE.toString(), gasLimit: 1_000_000});
112    expect(buyResult.events.TokenIsPurchased).is.not.undefined;161    expect(buyResult.events.TokenIsPurchased).is.not.undefined;
162
163    // Buyer pays only value, transaction use sponsoring
164    const buyerBalanceAfter = await helper.balance.getEthereum(buyerCross.eth);
165    expect(buyerBalanceAfter).to.be.eq(10n * ONE_TOKEN - PRICE);
166
113    ownerCross = await collection.methods.ownerOfCross(tokenId).call();167    ownerCross = await collection.methods.ownerOfCross(tokenId).call();
114    expect(ownerCross.eth).to.be.eq(buyerCross.eth);168    expect(ownerCross.eth).to.be.eq(buyerCross.eth);
115    expect(ownerCross.sub).to.be.eq(buyerCross.sub);169    expect(ownerCross.sub).to.be.eq(buyerCross.sub);
116  });170  });
117171
118  itEth('Put + Buy [sub]', async ({helper}) => {172  itEth('Put + Buy [sub]', async ({helper}) => {
173    const ONE_TOKEN = helper.balance.getOneTokenNominal();
119    const PRICE = 1n;174    const PRICE = 2n * ONE_TOKEN;  // 2 UNQ
120    const web3 = helper.getWeb3();175    const web3 = helper.getWeb3();
121    const marketOwner = await helper.eth.createAccountWithBalance(donor, 600n);176    const marketOwner = await helper.eth.createAccountWithBalance(donor, 600n);
122    const market = await deployMarket(helper, marketOwner);177    const market = await deployMarket(helper, marketOwner);
178    const contractHelpers = helper.ethNativeContract.contractHelpers(marketOwner);
179
180    // Set self sponsoring from contract balance
181    await contractHelpers.methods.selfSponsoredEnable(market.options.address).send({from: marketOwner});
182    await helper.eth.transferBalanceFromSubstrate(donor, market.options.address, 10n);
183
184    // Configure sponsoring
185    await contractHelpers.methods.setSponsoringMode(market.options.address, SponsoringMode.Generous).send({from: marketOwner});
186    await contractHelpers.methods.setSponsoringRateLimit(market.options.address, 0).send({from: marketOwner});
123187
124    const {collectionId, collectionAddress} = await helper.eth.createNFTCollection(marketOwner, 'Sponsor', 'absolutely anything', 'ROC');188    const {collectionId, collectionAddress} = await helper.eth.createNFTCollection(marketOwner, 'Sponsor', 'absolutely anything', 'ROC');
125    const collection = await helper.ethNativeContract.collection(collectionAddress, 'nft', marketOwner);189    const collection = helper.ethNativeContract.collection(collectionAddress, 'nft', marketOwner, true);
126190
191    // Set collection sponsoring
127    const [seller] = await helper.arrange.createAccounts([600n], donor);192    await collection.methods.setCollectionSponsor(marketOwner).send({from: marketOwner});
193    await collection.methods.confirmCollectionSponsorship().send({from: marketOwner});
194
128    const sellerMirror = helper.address.substrateToEth(seller.address);195    const seller = helper.util.fromSeed(`//Market-seller-${(new Date()).getTime()}`);
129    const sellerCross = helper.ethCrossAccount.fromKeyringPair(seller);196    const sellerCross = helper.ethCrossAccount.fromKeyringPair(seller);
197
198    // Seller has no funds at all, his transactions are sponsored
199    {
200      const sellerBalance = await helper.balance.getSubstrate(seller.address);
201      expect(sellerBalance).to.be.eq(0n);
202    }
203
130    const result = await collection.methods.mintCross(sellerCross, []).send();204    const result = await collection.methods.mintCross(sellerCross, []).send();
131    const tokenId = result.events.Transfer.returnValues.tokenId;205    const tokenId = result.events.Transfer.returnValues.tokenId;
132    await helper.nft.approveToken(seller, collectionId, tokenId, {Ethereum: market.options.address}, 1n);206    await helper.nft.approveToken(seller, collectionId, tokenId, {Ethereum: market.options.address});
133207
134    await helper.eth.sendEVM(seller, market.options.address, market.methods.put(collectionId, tokenId, PRICE, 1, sellerCross).encodeABI(), '0');208    await helper.eth.sendEVM(seller, market.options.address, market.methods.put(collectionId, tokenId, PRICE, 1, sellerCross).encodeABI(), '0');
209    // Seller balance is still zero
210    {
211      const sellerBalance = await helper.balance.getSubstrate(seller.address);
212      expect(sellerBalance).to.be.eq(0n);
213    }
135    let ownerCross = await collection.methods.ownerOfCross(tokenId).call();214    let ownerCross = await collection.methods.ownerOfCross(tokenId).call();
136    expect(ownerCross.eth).to.be.eq(sellerCross.eth);215    expect(ownerCross.eth).to.be.eq(sellerCross.eth);
137    expect(substrateAddressToHex(ownerCross.sub, web3)).to.be.eq(substrateAddressToHex(sellerCross.sub, web3));216    expect(substrateAddressToHex(ownerCross.sub, web3)).to.be.eq(substrateAddressToHex(sellerCross.sub, web3));
138217
139    const [buyer] = await helper.arrange.createAccounts([600n], donor);218    const [buyer] = await helper.arrange.createAccounts([600n], donor);
219    // Buyer has only expected balance
220    {
221      const buyerBalance = await helper.balance.getSubstrate(buyer.address);
222      expect(buyerBalance).to.be.eq(600n * ONE_TOKEN);
223    }
140    const buyerMirror = helper.address.substrateToEth(buyer.address);224    const buyerMirror = helper.address.substrateToEth(buyer.address);
141    const buyerCross = helper.ethCrossAccount.fromKeyringPair(buyer);225    const buyerCross = helper.ethCrossAccount.fromKeyringPair(buyer);
142    await helper.eth.transferBalanceFromSubstrate(donor, buyerMirror, 1n);226    await helper.eth.transferBalanceFromSubstrate(donor, buyerMirror, PRICE, false);
143    //TODO: change balance check to helper.balance.getSubstrate when implementation of sendMoney will be fixed in contract227
144    const sellerBalance = BigInt(await web3.eth.getBalance(sellerMirror));228    const buyerBalanceBefore = await helper.balance.getSubstrate(buyer.address);
145    await helper.eth.sendEVM(buyer, market.options.address, market.methods.buy(collectionId, tokenId, 1, buyerCross).encodeABI(), PRICE.toString());229    await helper.eth.sendEVM(buyer, market.options.address, market.methods.buy(collectionId, tokenId, 1, buyerCross).encodeABI(), PRICE.toString());
230    const buyerBalanceAfter = await helper.balance.getSubstrate(buyer.address);
231    // Buyer balance not changed: transaction is sponsored
232    expect(buyerBalanceBefore).to.be.eq(buyerBalanceAfter);
233
146    const sellerBalanceAfterBuy = BigInt(await web3.eth.getBalance(sellerMirror));234    const sellerBalanceAfterBuy = BigInt(await helper.balance.getSubstrate(seller.address));
147    ownerCross = await collection.methods.ownerOfCross(tokenId).call();235    ownerCross = await collection.methods.ownerOfCross(tokenId).call();
148    expect(ownerCross.eth).to.be.eq(buyerCross.eth);236    expect(ownerCross.eth).to.be.eq(buyerCross.eth);
149    expect(substrateAddressToHex(ownerCross.sub, web3)).to.be.eq(substrateAddressToHex(buyerCross.sub, web3));237    expect(substrateAddressToHex(ownerCross.sub, web3)).to.be.eq(substrateAddressToHex(buyerCross.sub, web3));
238
239    // Seller got only PRICE - MARKET_FEE
150    expect(sellerBalance + PRICE).to.be.equal(sellerBalanceAfterBuy);240    expect(sellerBalanceAfterBuy).to.be.eq(PRICE * BigInt(100 - MARKET_FEE) / 100n);
151  });241  });
152});242});
153243

modifiedtests/src/eth/tokenProperties.test.tsdiff before after both

561    itEth.ifWithPallets(`[${testCase.mode}] Can't be multiple set/read for non-existent token`, testCase.requiredPallets, async({helper}) => {561    itEth.ifWithPallets(`[${testCase.mode}] Can't be multiple set/read for non-existent token`, testCase.requiredPallets, async({helper}) => {
562      const caller = await helper.eth.createAccountWithBalance(donor);562      const caller = await helper.eth.createAccountWithBalance(donor);
563563
564      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });564      const properties = Array(5).fill(0).map((_, i) => ({key: `key_${i}`, value: Buffer.from(`value_${i}`)}));
565      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {tokenOwner: true,565      const permissions: ITokenPropertyPermission[] = properties.map(p => ({key: p.key, permission: {tokenOwner: true,
566        collectionAdmin: true,566        collectionAdmin: true,
567        mutable: true}}; });567        mutable: true}}));
568568
569      const collection = await helper[testCase.mode].mintCollection(alice, {569      const collection = await helper[testCase.mode].mintCollection(alice, {
570        tokenPrefix: 'ethp',570        tokenPrefix: 'ethp',