git.delta.rocks / unique-network / refs/commits / 3a01a5229f7a

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {usingPlaygrounds, expect, itSub} from '../util/playgrounds';
23import {createCollectionExpectSuccess, createItemExpectSuccess, uniqueEventMessage} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
2421
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2722
28describe('Burn Item event ', () => {23describe('Burn Item event ', () => {
29  let alice: IKeyringPair;24  let alice: IKeyringPair;
30  const checkSection = 'ItemDestroyed';
31  const checkTreasury = 'Deposit';
32  const checkSystem = 'ExtrinsicSuccess';
33  before(async () => {25  before(async () => {
34    await usingApi(async (api, privateKeyWrapper) => {26    await usingPlaygrounds(async (helper, privateKey) => {
35      alice = privateKeyWrapper('//Alice');27      const donor = privateKey('//Alice');
28      [alice] = await helper.arrange.createAccounts([10n], donor);
36    });29    });
37  });30  });
38  it('Check event from burnItem(): ', async () => {31  itSub('Check event from burnItem(): ', async ({helper}) => {
39    await usingApi(async (api: ApiPromise) => {32    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
33    const token = await collection.mintToken(alice, {Substrate: alice.address});
40      const collectionID = await createCollectionExpectSuccess();34    await token.burn(alice);
41      const itemID = await createItemExpectSuccess(alice, collectionID, 'NFT');35
42      const burnItem = api.tx.unique.burnItem(collectionID, itemID, 1);36    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
43      const events = await submitTransactionAsync(alice, burnItem);
44      const msg = JSON.stringify(uniqueEventMessage(events));37    const eventStrings = event.map(e => `${e.section}.${e.method}`);
38
45      expect(msg).to.be.contain(checkSection);39    expect(eventStrings).to.contains('common.ItemDestroyed');
46      expect(msg).to.be.contain(checkTreasury);40    expect(eventStrings).to.contains('treasury.Deposit');
47      expect(msg).to.be.contain(checkSystem);41    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
48    });
49  });42  });
50});43});
5144

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {usingPlaygrounds, itSub, expect} from '../util/playgrounds';
23import {uniqueEventMessage} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Create collection event ', () => {22describe('Create collection event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  const checkSection = 'CollectionCreated';
31  const checkTreasury = 'Deposit';
32  const checkSystem = 'ExtrinsicSuccess';
33  before(async () => {24  before(async () => {
34    await usingApi(async (api, privateKeyWrapper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
35      alice = privateKeyWrapper('//Alice');26      const donor = privateKey('//Alice');
27      [alice] = await helper.arrange.createAccounts([10n], donor);
36    });28    });
37  });29  });
38  it('Check event from createCollection(): ', async () => {30  itSub('Check event from createCollection(): ', async ({helper}) => {
39    await usingApi(async (api: ApiPromise) => {
40      const tx = api.tx.unique.createCollectionEx({name: [0x31], description: [0x32], tokenPrefix: '0x33', mode: 'NFT'});31    await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
41      const events = await submitTransactionAsync(alice, tx);32    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
42      const msg = JSON.stringify(uniqueEventMessage(events));33    const eventStrings = event.map(e => `${e.section}.${e.method}`);
34
43      expect(msg).to.be.contain(checkSection);35    expect(eventStrings).to.contains('common.CollectionCreated');
44      expect(msg).to.be.contain(checkTreasury);36    expect(eventStrings).to.contains('treasury.Deposit');
45      expect(msg).to.be.contain(checkSystem);37    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
46    });
47  });38  });
48});39});
4940

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {itSub, usingPlaygrounds, expect} from '../util/playgrounds';
23import {createCollectionExpectSuccess, uniqueEventMessage, normalizeAccountId} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Create Item event ', () => {22describe('Create Item event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  const checkSection = 'ItemCreated';
31  const checkTreasury = 'Deposit';
32  const checkSystem = 'ExtrinsicSuccess';
33  before(async () => {24  before(async () => {
34    await usingApi(async (api, privateKeyWrapper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
35      alice = privateKeyWrapper('//Alice');26      const donor = privateKey('//Alice');
27      [alice] = await helper.arrange.createAccounts([10n], donor);
36    });28    });
37  });29  });
38  it('Check event from createItem(): ', async () => {30  itSub('Check event from createItem(): ', async ({helper}) => {
39    await usingApi(async (api: ApiPromise) => {31    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
40      const collectionID = await createCollectionExpectSuccess();32    await collection.mintToken(alice, {Substrate: alice.address});
41      const createItem = api.tx.unique.createItem(collectionID, normalizeAccountId(alice.address), 'NFT');33    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
42      const events = await submitTransactionAsync(alice, createItem);
43      const msg = JSON.stringify(uniqueEventMessage(events));34    const eventStrings = event.map(e => `${e.section}.${e.method}`);
35
44      expect(msg).to.be.contain(checkSection);36    expect(eventStrings).to.contains('common.ItemCreated');
45      expect(msg).to.be.contain(checkTreasury);37    expect(eventStrings).to.contains('treasury.Deposit');
46      expect(msg).to.be.contain(checkSystem);38    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
47    });
48  });39  });
49});40});
5041

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {usingPlaygrounds, itSub, expect} from '../util/playgrounds';
23import {createCollectionExpectSuccess, uniqueEventMessage, normalizeAccountId} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Create Multiple Items Event event ', () => {22describe('Create Multiple Items Event event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  const checkSection = 'ItemCreated';
31  const checkTreasury = 'Deposit';
32  const checkSystem = 'ExtrinsicSuccess';
33  before(async () => {24  before(async () => {
34    await usingApi(async (api, privateKeyWrapper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
35      alice = privateKeyWrapper('//Alice');26      const donor = privateKey('//Alice');
27      [alice] = await helper.arrange.createAccounts([10n], donor);
36    });28    });
37  });29  });
38  it('Check event from createMultipleItems(): ', async () => {30  itSub('Check event from createMultipleItems(): ', async ({helper}) => {
39    await usingApi(async (api: ApiPromise) => {31    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
32
33    await collection.mintMultipleTokens(alice, [
34      {owner: {Substrate: alice.address}},
35      {owner: {Substrate: alice.address}},
40      const collectionID = await createCollectionExpectSuccess();36    ]);
41      const args = [{NFT: {}}, {NFT: {}}, {NFT: {}}];37
42      const createMultipleItems = api.tx.unique.createMultipleItems(collectionID, normalizeAccountId(alice.address), args);38    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
43      const events = await submitTransactionAsync(alice, createMultipleItems);
44      const msg = JSON.stringify(uniqueEventMessage(events));39    const eventStrings = event.map(e => `${e.section}.${e.method}`);
40
45      expect(msg).to.be.contain(checkSection);41    expect(eventStrings).to.contains('common.ItemCreated');
46      expect(msg).to.be.contain(checkTreasury);42    expect(eventStrings).to.contains('treasury.Deposit');
47      expect(msg).to.be.contain(checkSystem);43    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
48    });
49  });44  });
50});45});
5146

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {itSub, usingPlaygrounds, expect} from '../util/playgrounds';
23import {createCollectionExpectSuccess, uniqueEventMessage} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Destroy collection event ', () => {22describe('Destroy collection event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  const checkTreasury = 'Deposit';
31  const checkSystem = 'ExtrinsicSuccess';
32  before(async () => {24  before(async () => {
33    await usingApi(async (api, privateKeyWrapper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
34      alice = privateKeyWrapper('//Alice');26      const donor = privateKey('//Alice');
27      [alice] = await helper.arrange.createAccounts([10n], donor);
35    });28    });
36  });29  });
30
37  it('Check event from destroyCollection(): ', async () => {31  itSub('Check event from destroyCollection(): ', async ({helper}) => {
38    await usingApi(async (api: ApiPromise) => {32    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
39      const collectionID = await createCollectionExpectSuccess();33    await collection.burn(alice);
40      const destroyCollection = api.tx.unique.destroyCollection(collectionID);34    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
41      const events = await submitTransactionAsync(alice, destroyCollection);35    const eventStrings = event.map(e => `${e.section}.${e.method}`);
36
42      const msg = JSON.stringify(uniqueEventMessage(events));37    expect(eventStrings).to.contains('common.CollectionDestroyed');
43      expect(msg).to.be.contain(checkTreasury);38    expect(eventStrings).to.contains('treasury.Deposit');
44      expect(msg).to.be.contain(checkSystem);39    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
45    });
46  });40  });
47});41});
4842

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {usingPlaygrounds, expect, itSub} from '../util/playgrounds';
23import {createCollectionExpectSuccess, createItemExpectSuccess, uniqueEventMessage, normalizeAccountId} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Transfer event ', () => {22describe('Transfer event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  let bob: IKeyringPair;24  let bob: IKeyringPair;
31  const checkSection = 'Transfer';25
32  const checkTreasury = 'Deposit';
33  const checkSystem = 'ExtrinsicSuccess';
34  before(async () => {26  before(async () => {
35    await usingApi(async (api, privateKeyWrapper) => {27    await usingPlaygrounds(async (helper, privateKey) => {
36      alice = privateKeyWrapper('//Alice');28      const donor = privateKey('//Alice');
37      bob = privateKeyWrapper('//Bob');29      [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
38    });30    });
39  });31  });
32
40  it('Check event from transfer(): ', async () => {33  itSub('Check event from transfer(): ', async ({helper}) => {
41    await usingApi(async (api: ApiPromise) => {34    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
35    const token = await collection.mintToken(alice, {Substrate: alice.address});
42      const collectionID = await createCollectionExpectSuccess();36    await token.transfer(alice, {Substrate: bob.address});
43      const itemID = await createItemExpectSuccess(alice, collectionID, 'NFT');
44      const transfer = api.tx.unique.transfer(normalizeAccountId(bob.address), collectionID, itemID, 1);37    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
45      const events = await submitTransactionAsync(alice, transfer);
46      const msg = JSON.stringify(uniqueEventMessage(events));38    const eventStrings = event.map(e => `${e.section}.${e.method}`);
39
47      expect(msg).to.be.contain(checkSection);40    expect(eventStrings).to.contains('common.Transfer');
48      expect(msg).to.be.contain(checkTreasury);41    expect(eventStrings).to.contains('treasury.Deposit');
49      expect(msg).to.be.contain(checkSystem);42    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
50    });
51  });43  });
52});44});
5345

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits17// https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
18import {ApiPromise} from '@polkadot/api';
19import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
20import chai from 'chai';
21import chaiAsPromised from 'chai-as-promised';
22import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';19import {usingPlaygrounds, expect, itSub} from '../util/playgrounds';
23import {createCollectionExpectSuccess, createItemExpectSuccess, uniqueEventMessage, normalizeAccountId} from '../util/helpers';20import {IEvent} from '../util/playgrounds/types';
24
25chai.use(chaiAsPromised);
26const expect = chai.expect;
2721
28describe('Transfer from event ', () => {22describe('Transfer event ', () => {
29  let alice: IKeyringPair;23  let alice: IKeyringPair;
30  let bob: IKeyringPair;24  let bob: IKeyringPair;
31  const checkSection = 'Transfer';
32  const checkTreasury = 'Deposit';
33  const checkSystem = 'ExtrinsicSuccess';
34  before(async () => {25  before(async () => {
35    await usingApi(async (api, privateKeyWrapper) => {26    await usingPlaygrounds(async (helper, privateKey) => {
36      alice = privateKeyWrapper('//Alice');27      const donor = privateKey('//Alice');
37      bob = privateKeyWrapper('//Bob');28      [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
38    });29    });
39  });30  });
31
40  it('Check event from transferFrom(): ', async () => {32  itSub('Check event from transfer(): ', async ({helper}) => {
41    await usingApi(async (api: ApiPromise) => {33    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
34    const token = await collection.mintToken(alice, {Substrate: alice.address});
42      const collectionID = await createCollectionExpectSuccess();35    await token.transferFrom(alice, {Substrate: alice.address}, {Substrate: bob.address});
43      const itemID = await createItemExpectSuccess(alice, collectionID, 'NFT');
44      const transferFrom = api.tx.unique.transferFrom(normalizeAccountId(alice.address), normalizeAccountId(bob.address), collectionID, itemID, 1);36    const event = helper.chainLog[helper.chainLog.length - 1].events as IEvent[];
45      const events = await submitTransactionAsync(alice, transferFrom);
46      const msg = JSON.stringify(uniqueEventMessage(events));37    const eventStrings = event.map(e => `${e.section}.${e.method}`);
38
47      expect(msg).to.be.contain(checkSection);39    expect(eventStrings).to.contains('common.Transfer');
48      expect(msg).to.be.contain(checkTreasury);40    expect(eventStrings).to.contains('treasury.Deposit');
49      expect(msg).to.be.contain(checkSystem);41    expect(eventStrings).to.contains('system.ExtrinsicSuccess');
50    });
51  });42  });
52});43});
5344

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {expect} from 'chai';
19import {isAllowlisted, normalizeAccountId} from '../util/helpers';
20import {
21  contractHelpers,
22  createEthAccount,
23  createEthAccountWithBalance,
24  deployFlipper,
25  evmCollection,
26  evmCollectionHelpers,
27  getCollectionAddressFromResult,
28  itWeb3,
29} from './util/helpers';
30import {itEth, usingEthPlaygrounds} from './util/playgrounds';18import {itEth, usingEthPlaygrounds, expect} from './util/playgrounds';
3119
32describe('EVM contract allowlist', () => {20describe('EVM contract allowlist', () => {
21  let donor: IKeyringPair;
22
23  before(async function() {
24    await usingEthPlaygrounds(async (_helper, privateKey) => {
25      donor = privateKey('//Alice');
26    });
27  });
28
33  itWeb3('Contract allowlist can be toggled', async ({api, web3, privateKeyWrapper}) => {29  itEth('Contract allowlist can be toggled', async ({helper}) => {
34    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);30    const owner = await helper.eth.createAccountWithBalance(donor);
35    const flipper = await deployFlipper(web3, owner);31    const flipper = await helper.eth.deployFlipper(owner);
36
37    const helpers = contractHelpers(web3, owner);32    const helpers = helper.ethNativeContract.contractHelpers(owner);
3833
39    // Any user is allowed by default34    // Any user is allowed by default
40    expect(await helpers.methods.allowlistEnabled(flipper.options.address).call()).to.be.false;35    expect(await helpers.methods.allowlistEnabled(flipper.options.address).call()).to.be.false;
48    expect(await helpers.methods.allowlistEnabled(flipper.options.address).call()).to.be.false;43    expect(await helpers.methods.allowlistEnabled(flipper.options.address).call()).to.be.false;
49  });44  });
5045
51  itWeb3('Non-allowlisted user can\'t call contract with allowlist enabled', async ({api, web3, privateKeyWrapper}) => {46  itEth('Non-allowlisted user can\'t call contract with allowlist enabled', async ({helper}) => {
52    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);47    const owner = await helper.eth.createAccountWithBalance(donor);
53    const flipper = await deployFlipper(web3, owner);48    const caller = await helper.eth.createAccountWithBalance(donor);
54    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);49    const flipper = await helper.eth.deployFlipper(owner);
55
56    const helpers = contractHelpers(web3, owner);50    const helpers = helper.ethNativeContract.contractHelpers(owner);
5751
58    // User can flip with allowlist disabled52    // User can flip with allowlist disabled
59    await flipper.methods.flip().send({from: caller});53    await flipper.methods.flip().send({from: caller});

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {17import {
18  collectionIdToAddress,
19  createEthAccount,
20  createEthAccountWithBalance,
21  deployFlipper,
22  ethBalanceViaSub,18  ethBalanceViaSub,
23  GAS_ARGS,19  GAS_ARGS,
24  itWeb3,
25  recordEthFee,20  recordEthFee,
26  usingWeb3,
27} from './util/helpers';21} from './util/helpers';
28import {expect} from 'chai';22import {Contract} from 'web3-eth-contract';
23
29import {createCollectionExpectSuccess, createItemExpectSuccess, UNIQUE} from '../util/helpers';24import {IKeyringPair} from '@polkadot/types/types';
30import nonFungibleAbi from './nonFungibleAbi.json';
31import {Contract} from 'web3-eth-contract';25import {EthUniqueHelper, itEth, usingEthPlaygrounds, expect} from './util/playgrounds';
32import Web3 from 'web3';
3326
34describe('Contract calls', () => {27describe('Contract calls', () => {
28  let donor: IKeyringPair;
29
30  before(async function() {
31    await usingEthPlaygrounds(async (_helper, privateKey) => {
32      donor = privateKey('//Alice');
33    });
34  });
35
35  itWeb3('Call of simple contract fee is less than 0.2 UNQ', async ({web3, api, privateKeyWrapper}) => {36  itEth('Call of simple contract fee is less than 0.2 UNQ', async ({helper}) => {
36    const deployer = await createEthAccountWithBalance(api, web3, privateKeyWrapper);37    const deployer = await helper.eth.createAccountWithBalance(donor);
37    const flipper = await deployFlipper(web3, deployer);38    const flipper = await helper.eth.deployFlipper(deployer);
3839
39    const cost = await recordEthFee(api, deployer, () => flipper.methods.flip().send({from: deployer}));40    const cost = await recordEthFee(helper.api!, deployer, () => flipper.methods.flip().send({from: deployer}));
40    expect(cost < BigInt(0.2 * Number(UNIQUE))).to.be.true;41    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal()))).to.be.true;
41  });42  });
4243
43  itWeb3('Balance transfer fee is less than 0.2 UNQ', async ({web3, api, privateKeyWrapper}) => {44  itEth('Balance transfer fee is less than 0.2 UNQ', async ({helper}) => {
44    const userA = await createEthAccountWithBalance(api, web3, privateKeyWrapper);45    const userA = await helper.eth.createAccountWithBalance(donor);
45    const userB = createEthAccount(web3);46    const userB = helper.eth.createAccount();
46
47    const cost = await recordEthFee(api, userA, () => web3.eth.sendTransaction({from: userA, to: userB, value: '1000000', ...GAS_ARGS}));47    const cost = await recordEthFee(helper.api!, userA, () => helper.web3!.eth.sendTransaction({from: userA, to: userB, value: '1000000', ...GAS_ARGS}));
48    const balanceB = await ethBalanceViaSub(api, userB);48    const balanceB = await ethBalanceViaSub(helper.api!, userB);
49    expect(cost - balanceB < BigInt(0.2 * Number(UNIQUE))).to.be.true;49    expect(cost - balanceB < BigInt(0.2 * Number(helper.balance.getOneTokenNominal()))).to.be.true;
50  });50  });
5151
52  itWeb3('NFT transfer is close to 0.15 UNQ', async ({web3, api, privateKeyWrapper}) => {52  itEth('NFT transfer is close to 0.15 UNQ', async ({helper}) => {
53    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);53    const caller = await helper.eth.createAccountWithBalance(donor);
54    const receiver = createEthAccount(web3);54    const receiver = helper.eth.createAccount();
5555
56    const alice = privateKeyWrapper('//Alice');56    const [alice] = await helper.arrange.createAccounts([10n], donor);
57    const collection = await createCollectionExpectSuccess({57    const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
58      mode: {type: 'NFT'},
59    });
60    const itemId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: caller});58    const {tokenId} = await collection.mintToken(alice, {Ethereum: caller});
6159
62    const address = collectionIdToAddress(collection);60    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
63    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});61    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
6462
65    const cost = await recordEthFee(api, caller, () => contract.methods.transfer(receiver, itemId).send(caller));63    const cost = await recordEthFee(helper.api!, caller, () => contract.methods.transfer(receiver, tokenId).send(caller));
6664
67    const fee = Number(cost) / Number(UNIQUE);65    const fee = Number(cost) / Number(helper.balance.getOneTokenNominal());
68    const expectedFee = 0.15;66    const expectedFee = 0.15;
69    const tolerance = 0.001;67    const tolerance = 0.001;
7068
78  let collection: number;76  let collection: number;
79  let minter: string;77  let minter: string;
8078
81  function contract(web3: Web3): Contract {79  function contract(helper: EthUniqueHelper): Contract {
82    return new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collection), {from: minter, ...GAS_ARGS});80    return helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection), 'nft', minter);
83  }81  }
8482
85  before(async () => {83  before(async () => {
86    await usingWeb3 (async (web3) => {84    await usingEthPlaygrounds(async (helper, privateKey) => {
85      const donor = privateKey('//Alice');
86      const [alice] = await helper.arrange.createAccounts([10n], donor);
87      collection = await createCollectionExpectSuccess();87      ({collectionId: collection} = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'}));
88      minter = createEthAccount(web3);88      minter = helper.eth.createAccount();
89    });89    });
90  });90  });
9191
92  itWeb3('interfaceID == 0xffffffff always false', async ({web3}) => {92  itEth('interfaceID == 0xffffffff always false', async ({helper}) => {
93    expect(await contract(web3).methods.supportsInterface('0xffffffff').call()).to.be.false;93    expect(await contract(helper).methods.supportsInterface('0xffffffff').call()).to.be.false;
94  });94  });
9595
96  itWeb3('ERC721 support', async ({web3}) => {96  itEth('ERC721 support', async ({helper}) => {
97    expect(await contract(web3).methods.supportsInterface('0x780e9d63').call()).to.be.true;97    expect(await contract(helper).methods.supportsInterface('0x780e9d63').call()).to.be.true;
98  });98  });
9999
100  itWeb3('ERC721Metadata support', async ({web3}) => {100  itEth('ERC721Metadata support', async ({helper}) => {
101    expect(await contract(web3).methods.supportsInterface('0x5b5e139f').call()).to.be.true;101    expect(await contract(helper).methods.supportsInterface('0x5b5e139f').call()).to.be.true;
102  });102  });
103103
104  itWeb3('ERC721Mintable support', async ({web3}) => {104  itEth('ERC721Mintable support', async ({helper}) => {
105    expect(await contract(web3).methods.supportsInterface('0x68ccfe89').call()).to.be.true;105    expect(await contract(helper).methods.supportsInterface('0x68ccfe89').call()).to.be.true;
106  });106  });
107107
108  itWeb3('ERC721Enumerable support', async ({web3}) => {108  itEth('ERC721Enumerable support', async ({helper}) => {
109    expect(await contract(web3).methods.supportsInterface('0x780e9d63').call()).to.be.true;109    expect(await contract(helper).methods.supportsInterface('0x780e9d63').call()).to.be.true;
110  });110  });
111111
112  itWeb3('ERC721UniqueExtensions support', async ({web3}) => {112  itEth('ERC721UniqueExtensions support', async ({helper}) => {
113    expect(await contract(web3).methods.supportsInterface('0xd74d154f').call()).to.be.true;113    expect(await contract(helper).methods.supportsInterface('0xd74d154f').call()).to.be.true;
114  });114  });
115115
116  itWeb3('ERC721Burnable support', async ({web3}) => {116  itEth('ERC721Burnable support', async ({helper}) => {
117    expect(await contract(web3).methods.supportsInterface('0x42966c68').call()).to.be.true;117    expect(await contract(helper).methods.supportsInterface('0x42966c68').call()).to.be.true;
118  });118  });
119119
120  itWeb3('ERC165 support', async ({web3}) => {120  itEth('ERC165 support', async ({helper}) => {
121    expect(await contract(web3).methods.supportsInterface('0x01ffc9a7').call()).to.be.true;121    expect(await contract(helper).methods.supportsInterface('0x01ffc9a7').call()).to.be.true;
122  });122  });
123});123});
124124