git.delta.rocks / unique-network / refs/commits / d1696cc2487d

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -213,7 +213,8 @@
 			balances: endowed_accounts
 				.iter()
 				.cloned()
-				.map(|k| (k, 1 << 70))
+				// 1e13 UNQ
+				.map(|k| (k, 1 << 100))
 				.collect(),
 		},
 		treasury: Default::default(),

13describe('Matcher contract usage', () => {13describe('Matcher contract usage', () => {
14  itWeb3('With UNQ', async ({api, web3}) => {14  itWeb3('With UNQ', async ({api, web3}) => {
15    const alice = privateKey('//Alice');15    const alice = privateKey('//Alice');
16    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
17    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId));
18    const matcherOwner = await createEthAccountWithBalance(api, web3);16    const matcherOwner = await createEthAccountWithBalance(api, web3);
19    const helpers = contractHelpers(web3, matcherOwner);
20
21    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {17    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
22      from: matcherOwner,18      from: matcherOwner,
23      ...GAS_ARGS,19      ...GAS_ARGS,
24    });20    });
25    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments:[matcherOwner]}).send({from: matcherOwner});21    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments:[matcherOwner]}).send({from: matcherOwner});
2622    const helpers = contractHelpers(web3, matcherOwner);
27    await transferBalanceToEth(api, alice, matcher.options.address);23    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});
28    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});24    await helpers.methods.setSponsoringRateLimit(matcher.options.address, 1).send({from: matcherOwner});
29
30    await transferBalanceToEth(api, alice, subToEth(alice.address));25    await transferBalanceToEth(api, alice, matcher.options.address);
26
27    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
28    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});
31    await setCollectionSponsorExpectSuccess(collectionId, alice.address);29    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
32    await confirmSponsorshipExpectSuccess(collectionId);30    await confirmSponsorshipExpectSuccess(collectionId);
3331
34    const seller = privateKey('//Seller/' + Date.now());32    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(alice.address), true).send({from: matcherOwner});
35    await addToAllowListExpectSuccess(alice, collectionId, {Ethereum:subToEth(seller.address)});33    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(alice.address)));
34
35    const seller = privateKey('//Bob');
36    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});36    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});
37    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(seller.address)));
3738
38    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);39    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);
3940
40    // To transfer item to matcher it first needs to be transfered to EVM account of seller41    // To transfer item to matcher it first needs to be transfered to EVM account of bob
41    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});42    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});
43
44    // Token is owned by seller initially
42    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});45    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});
4346
44    // Ask47    // Ask
45    {48    {
46      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));49      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));
47      await executeEthTxOnSub(web3, api, seller, matcher, m => m.setAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));50      await executeEthTxOnSub(web3, api, seller, matcher, m => m.addAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));
48    }51    }
4952
50    // Token is transferred to matcher53    // Token is transferred to matcher
6972
70  // selling for custom tokens excluded from release73  // selling for custom tokens excluded from release
71  itWeb3.skip('With custom ERC20', async ({api, web3}) => {74  itWeb3.skip('With custom ERC20', async ({api, web3}) => {
75    const alice = privateKey('//Alice');
72    const matcherOwner = await createEthAccountWithBalance(api, web3);76    const matcherOwner = await createEthAccountWithBalance(api, web3);
73    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {77    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
74      from: matcherOwner,78      from: matcherOwner,
75      ...GAS_ARGS,79      ...GAS_ARGS,
76    });80    });
77    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner});81    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner});
7882
79    const alice = privateKey('//Alice');
80    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});83    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
81    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});84    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});
8285
100    // Ask103    // Ask
101    {104    {
102      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));105      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));
103      await executeEthTxOnSub(web3, api, seller, matcher, m => m.setAsk(PRICE, evmFungible.options.address, evmCollection.options.address, tokenId, 1));106      await executeEthTxOnSub(web3, api, seller, matcher, m => m.addAsk(PRICE, evmFungible.options.address, evmCollection.options.address, tokenId, 1));
104    }107    }
105108
106    // Token is transferred to matcher109    // Token is transferred to matcher
134137
135  itWeb3('With escrow', async ({api, web3}) => {138  itWeb3('With escrow', async ({api, web3}) => {
136    const alice = privateKey('//Alice');139    const alice = privateKey('//Alice');
137    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
138    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId));
139    const matcherOwner = await createEthAccountWithBalance(api, web3);140    const matcherOwner = await createEthAccountWithBalance(api, web3);
140    const helpers = contractHelpers(web3, matcherOwner);
141    const escrow = await createEthAccountWithBalance(api, web3);141    const escrow = await createEthAccountWithBalance(api, web3);
142
143    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {142    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
144      from: matcherOwner,143      from: matcherOwner,
145      ...GAS_ARGS,144      ...GAS_ARGS,
146    });145    });
147    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner});146    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner, gas: 10000000});
148    await matcher.methods.setEscrow(escrow).send({from: matcherOwner});147    await matcher.methods.setEscrow(escrow).send({from: matcherOwner});
149148    const helpers = contractHelpers(web3, matcherOwner);
150    await transferBalanceToEth(api, alice, matcher.options.address);149    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});
151    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});150    await helpers.methods.setSponsoringRateLimit(matcher.options.address, 1).send({from: matcherOwner});
152
153    await transferBalanceToEth(api, alice, subToEth(alice.address));151    await transferBalanceToEth(api, alice, matcher.options.address);
152
153    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
154    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});
154    await setCollectionSponsorExpectSuccess(collectionId, alice.address);155    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
155    await confirmSponsorshipExpectSuccess(collectionId);156    await confirmSponsorshipExpectSuccess(collectionId);
157
158    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(alice.address), true).send({from: matcherOwner});
159    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(alice.address)));
156160
157    const seller = privateKey('//Seller/' + Date.now());161    const seller = privateKey('//Bob');
158    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});162    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});
159    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(seller.address)));163    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(seller.address)));
160164
161    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);165    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);
162166
163    // To transfer item to matcher it first needs to be transfered to EVM account of seller167    // To transfer item to matcher it first needs to be transfered to EVM account of bob
164    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});168    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});
169
170    // Token is owned by seller initially
165    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});171    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});
166172
167    // Ask173    // Ask
168    {174    {
169      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));175      await executeEthTxOnSub(web3, api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));
170      await executeEthTxOnSub(web3, api, seller, matcher, m => m.setAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));176      await executeEthTxOnSub(web3, api, seller, matcher, m => m.addAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));
171    }177    }
172178
173    // Token is transferred to matcher179    // Token is transferred to matcher

--- a/tests/src/eth/payable.test.ts
+++ b/tests/src/eth/payable.test.ts
@@ -1,7 +1,7 @@
 import {expect} from 'chai';
 import privateKey from '../substrate/privateKey';
 import {submitTransactionAsync} from '../substrate/substrate-api';
-import {createEthAccountWithBalance, deployCollector, GAS_ARGS, itWeb3, subToEth} from './util/helpers';
+import {createEthAccountWithBalance, deployCollector, GAS_ARGS, itWeb3, subToEth, transferBalanceToEth} from './util/helpers';
 import {evmToAddress} from '@polkadot/util-crypto';
 import {getGenericResult} from '../util/helpers';
 import {getBalanceSingle, transferBalanceExpectSuccess} from '../substrate/get-balance';
@@ -23,7 +23,7 @@
 
     // Transaction fee/value will be payed from subToEth(sender) evm balance,
     // which is backed by evmToAddress(subToEth(sender)) substrate balance
-    await transferBalanceExpectSuccess(api, alice, evmToAddress(subToEth(alice.address)), '1000000000000');
+    await transferBalanceToEth(api, alice, subToEth(alice.address));
 
     {
       const tx = api.tx.evm.call(

--- a/tests/src/eth/util/helpers.ts
+++ b/tests/src/eth/util/helpers.ts
@@ -19,7 +19,7 @@
 import contractHelpersAbi from './contractHelpersAbi.json';
 import getBalance from '../../substrate/get-balance';
 
-export const GAS_ARGS = {gas: 1000000};
+export const GAS_ARGS = {gas: 2500000};
 
 let web3Connected = false;
 export async function usingWeb3<T>(cb: (web3: Web3) => Promise<T> | T): Promise<T> {
@@ -63,7 +63,7 @@
   return account;
 }
 
-export async function transferBalanceToEth(api: ApiPromise, source: IKeyringPair, target: string, amount = 10000n * UNIQUE) {
+export async function transferBalanceToEth(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {
   const tx = api.tx.balances.transfer(evmToAddress(target), amount);
   const events = await submitTransactionAsync(source, tx);
   const result = getGenericResult(events);
@@ -234,7 +234,7 @@
  * @param mkTx - closure, receiving `contract.methods`, and returning method call,
  * to be used as following (assuming `to` = erc20 contract):
  * `m => m.transfer(to, amount)`
- * 
+ *
  * # Example
  * ```ts
  * executeEthTxOnSub(api, alice, erc20Contract, m => m.transfer(target, amount));
@@ -260,7 +260,7 @@
 
 /**
  * Measure how much gas given closure consumes
- * 
+ *
  * @param user which user balance will be checked
  */
 export async function recordEthFee(api: ApiPromise, user: string, call: () => Promise<any>): Promise<bigint> {